Package xformslib :: Module library
[hide private]
[frames] | no frames]

Source Code for Module xformslib.library

    1  #!/usr/bin/env python 
    2  # -*- coding: iso8859-1 -*- 
    3   
    4  """ 
    5      xforms-python 
    6      Python wrapper for XForms (X11) GUI C toolkit library using ctypes 
    7   
    8      Copyright (C) 2009  Luca Lazzaroni "LukenShiro"  <lukenshiro@ngi.it> 
    9   
   10      This program is free software: you can redistribute it and/or modify 
   11      it under the terms of the GNU Lesser General Public License as 
   12      published by the Free Software Foundation, version 2.1 of the License. 
   13   
   14      This program is distributed in the hope that it will be useful, 
   15      but WITHOUT ANY WARRANTY; without even the implied warranty of 
   16      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
   17      GNU Lesser General Public License for more details. 
   18   
   19      You should have received a copy of the GNU LGPL along with this 
   20      program. If not, see <http://www.gnu.org/licenses/>. 
   21   
   22      See CREDITS file to read acknowledgements and thanks to XForms, 
   23      ctypes and other developers. 
   24  """ 
   25   
   26  # originally generated by 'h2xml+gccxml' and 'xml2py' 
   27  # then heavily reordered and reworked 
   28   
   29  # ############################################# # 
   30  # Interface to XForms shared object libraries   # 
   31  # ############################################# # 
   32   
   33  import ctypes as cty 
   34  import ctypes.util as ctyutil 
   35  import sys 
   36  import warnings 
   37  from xfdata import *       # data types and constants from XForms 
   38   
   39   
   40  # xforms-python version 
   41  __mainversion__ = "0.3.1"               # real version 
   42  __vers_against_xforms__ = "1.0.93pre2"   # xforms version to be built against 
   43  __version__ = __mainversion__+"_"+__vers_against_xforms__ 
   44   
   45   
   46  header_filename = "/usr/include/forms.h" 
   47   
   48   
49 -def get_xforms_version():
50 """ Return version string of installed XForms library/header 51 """ 52 53 complete_xf_version = "" 54 try: 55 formsh = open(header_filename, "r") 56 except IOError: 57 raise XFormsLoadError("XForms library toolkit header is not " \ 58 " installed properly") 59 else: 60 try: 61 # a reasonable size to catch version values 62 fconten = formsh.read(2500) 63 except IOError: 64 raise XFormsLoadError("XForms library toolkit header is not " \ 65 "installed properly") 66 else: 67 formsh.close() 68 listconten = fconten.split("\n") 69 for singline in listconten: 70 idx_ver = singline.find("FL_VERSION") 71 if idx_ver != -1: 72 strg_ver1 = singline[idx_ver:len(singline)] 73 strg_ver = strg_ver1.replace("FL_VERSION", "").strip(" ") 74 break 75 for singline in listconten: 76 idx_rev = singline.find("FL_REVISION") 77 if idx_rev != -1: 78 strg_rev1 = singline[idx_rev:len(singline)] 79 strg_rev = strg_rev1.replace("FL_REVISION", "").strip(" ") 80 break 81 for singline in listconten: 82 idx_fix = singline.find("FL_FIXLEVEL") 83 if idx_fix != -1: 84 strg_fix1 = singline[idx_fix:len(singline)] 85 strg_fix = strg_fix1.replace("FL_FIXLEVEL", \ 86 "").strip(" ").strip('"') 87 break 88 complete_xf_version = strg_ver+"."+strg_rev+"."+strg_fix 89 90 return complete_xf_version
91 92
93 -def verify_version_compatibility():
94 """ verify compatibility between xforms-python version and XForms version 95 """ 96 97 xforms_vers = get_xforms_version() 98 if __vers_against_xforms__ != xforms_vers: # no match 99 warningmsg = "xforms-python is implemented against XForms version " \ 100 " %s and does not match XForms installed version " \ 101 "(%s). Some compatibility problems may arise if XForms" \ 102 " public interface has been modified." % \ 103 (__vers_against_xforms__, xforms_vers) 104 warnings.warn(warningmsg, UserWarning)
105 106
107 -class XFormsLoadError(OSError):
108 """ Error in loading shared object library """ 109 110 pass
111 112
113 -class XFormsTypeError(TypeError):
114 """ Generic error for type mismatch """ 115 116 pass
117 118
119 -def warn_deprecated_function(altfunc=""):
120 """ Warns the user when a function is deprecated and should not be used 121 anymore. If a param is provided it may advide the user about an 122 alternative function. 123 """ 124 125 funcname = sys._getframe(1).f_code.co_name 126 if altfunc: 127 newaltfunc = "Use %s instead." % altfunc 128 else: 129 newaltfunc = "" 130 warningmsg = "Function %s is deprecated and might be removed in future" \ 131 " releases. %s" % (funcname, newaltfunc) 132 warnings.warn(warningmsg, DeprecationWarning, 3)
133 134
135 -def func_do_nothing_placeholder(cfunction):
136 """ Print a warning if called function doesn't exist 137 """ 138 139 warningmsg = "C function %s does NOT exist, hence its call is ignored," \ 140 " hence it is not wrappable and callable in python, as " \ 141 "well. Maybe removed or disabled?" % cfunction 142 warnings.warn(warningmsg, UserWarning) 143 return None
144 145 146 # placeholders to keep reference to c functions 147 # keeps global to avoid garbage collector's' unpredictable behaviour 148 _cfunc_refs = [] 149 # just in case, maintains elements used as parameters, too 150 _elem_refs = [] 151 152
153 -def keep_cfunc_refs(*cfunclist):
154 """ Adds a reference for _cfunc_refs list of values 155 """ 156 157 for singvalue in cfunclist: 158 _cfunc_refs.append(singvalue)
159 160
161 -def keep_elem_refs(*elemlist):
162 """ Adds a reference for _elem_refs list of values 163 """ 164 165 for singvalue in elemlist: 166 _elem_refs.append(singvalue)
167 168 169 loaded_xlibraries = {'libforms' : None, 'libflimage' : None, \ 170 'libformsgl' : None, 'libx11' : None} 171 172
173 -def load_so_libforms():
174 """ Load libforms.so else raise an error -> library instance 175 """ 176 177 if loaded_xlibraries['libforms'] is None: 178 libfbase = ctyutil.find_library("forms") 179 if not libfbase: # not installed 180 raise XFormsLoadError("XForms library toolkit is not installed" \ 181 " properly") 182 else: 183 loaded_xlibraries['libforms'] = cty.cdll.LoadLibrary(libfbase) 184 return loaded_xlibraries['libforms']
185 186
187 -def load_so_libflimage():
188 """ Load libflimage.so else raise an error -> library instance 189 """ 190 191 if loaded_xlibraries['libflimage'] is None: 192 libfimg = ctyutil.find_library("flimage") 193 if not libfimg: # not installed 194 raise XFormsLoadError("XForms library toolkit is not installed" \ 195 " properly") 196 else: 197 loaded_xlibraries['libflimage'] = cty.cdll.LoadLibrary(libfimg) 198 return loaded_xlibraries['libflimage']
199 200
201 -def load_so_libformsgl():
202 """ Load libformsGL.so else raise an error -> library instance 203 """ 204 205 if loaded_xlibraries['libformsgl'] is None: 206 libfgl = ctyutil.find_library("formsGL") 207 if not libfgl: # not installed 208 raise XFormsLoadError("XForms library toolkit is not installed" \ 209 " properly, with OpenGL support") 210 else: 211 loaded_xlibraries['libformsgl'] = cty.cdll.LoadLibrary(libfgl) 212 return loaded_xlibraries['libformsgl']
213 214
215 -def load_so_libx11():
216 """ Load libX11.so.6 else raise an error -> library instance 217 """ 218 219 if loaded_xlibraries['libx11'] is None: 220 libx11 = ctyutil.find_library("X11") 221 if not libx11: # not installed 222 raise XFormsLoadError("X11 libraries are not installed" \ 223 " properly") 224 else: 225 loaded_xlibraries['libx11'] = cty.cdll.LoadLibrary(libx11) 226 return loaded_xlibraries['libx11']
227 228
229 -def cfuncproto(library, cfuncname, retval, arglist, doc=""):
230 """ Prototype for C function to be wrapped in python 231 """ 232 233 loadedfunc = None 234 try: 235 loadedfunc = getattr(library, cfuncname) 236 except AttributeError: 237 # function doesn't exist 238 loadedfunc = func_do_nothing_placeholder(cfuncname) 239 else: 240 loadedfunc.restype = retval 241 loadedfunc.argtypes = arglist 242 loadedfunc.__doc__ = doc 243 244 return loadedfunc
245 246 247 # functions to convert a parameter into a python type then into the 248 # equivalent ctypes type 249
250 -def convert_to_string(paramname):
251 """ Converts paramname to python str and to ctypes c_char_p """ 252 253 try: 254 retv0 = str(paramname) 255 except ValueError: 256 raise XFormsTypeError("Parameter cannot be converted into" \ 257 "'str'/'c_char_p'") 258 retv = cty.c_char_p(retv0) 259 #print "string", paramname, retv0, retv 260 return retv
261 262
263 -def convert_to_int(paramname):
264 """ Converts paramname to python int and to ctypes c_int """ 265 266 if not isinstance(paramname, cty.c_int): 267 try: 268 retv0 = int(paramname) 269 except ValueError: 270 raise XFormsTypeError("Parameter cannot be converted into" \ 271 " 'int'/'c_int'") 272 retv = cty.c_int(retv0) 273 #print "int", paramname, retv0, retv 274 return retv 275 else: 276 return paramname
277 278 convert_to_FL_Coord = convert_to_int 279 280
281 -def convert_to_uint(paramname):
282 """ Converts paramname to python int and to ctypes c_uint """ 283 284 if not isinstance(paramname, cty.c_int): 285 try: 286 retv0 = int(paramname) 287 except ValueError: 288 raise XFormsTypeError("Parameter cannot be converted into" \ 289 " 'int'/'c_uint'") 290 else: 291 retv = cty.c_uint(retv0) 292 #print "uint", paramname, retv0, retv 293 return retv 294 else: 295 return paramname
296 297
298 -def convert_to_long(paramname):
299 """ Converts paramname to python long and to ctypes c_long """ 300 301 if not isinstance(paramname, cty.c_long): 302 try: 303 retv0 = long(paramname) 304 except ValueError: 305 raise XFormsTypeError("Parameter cannot be converted into" \ 306 " 'long'/'c_long'") 307 else: 308 retv = cty.c_long(retv0) 309 #print "long", paramname, retv0, retv 310 return retv 311 else: 312 return paramname
313 314
315 -def convert_to_ulong(paramname):
316 """ Converts paramname to python long and to ctypes c_ulong """ 317 318 if not isinstance(paramname, cty.c_ulong): 319 try: 320 retv0 = long(paramname) 321 except ValueError: 322 raise XFormsTypeError("Parameter cannot be converted into" \ 323 " 'long'/'c_ulong'") 324 else: 325 retv = cty.c_ulong(retv0) 326 #print "ulong", paramname, retv0, retv 327 return retv 328 else: 329 return paramname
330 331 332 convert_to_FL_COLOR = convert_to_ulong 333 convert_to_Window = convert_to_ulong 334 convert_to_Pixmap = convert_to_ulong 335 336
337 -def convert_to_double(paramname):
338 """ Converts paramname to python float and to ctypes c_double """ 339 340 if not isinstance(paramname, cty.c_double): 341 try: 342 retv0 = float(paramname) 343 except ValueError: 344 raise XFormsTypeError("Parameter cannot be converted into" \ 345 " 'float'/'c_double'") 346 else: 347 retv = cty.c_double(retv0) 348 #print "double", paramname, retv0, retv 349 return retv 350 else: 351 return paramname
352 353
354 -def convert_to_float(paramname):
355 """ Converts paramname to python float and to ctypes c_float """ 356 357 if not isinstance(paramname, cty.c_float): 358 try: 359 retv0 = float(paramname) 360 except ValueError: 361 raise XFormsTypeError("Parameter cannot be converted into" \ 362 " 'float'/'c_float'") 363 else: 364 retv = cty.c_float(retv0) 365 #print "float", paramname, retv0, retv 366 return retv 367 else: 368 return paramname
369 370
371 -def convert_to_ubyte(paramname):
372 """ Converts paramname to ctypes c_ubyte """ 373 374 retv = cty.c_ubyte(paramname) 375 return retv
376 377
378 -def make_int_and_pointer():
379 """ Makes a ctypes c_int and its pointer, and returns both """ 380 381 baseval = cty.c_int() 382 ptrbaseval = cty.byref(baseval) 383 return baseval, ptrbaseval
384 385 make_FL_Coord_and_pointer = make_int_and_pointer 386 387
388 -def make_uint_and_pointer():
389 """ Makes a ctypes c_uint and its pointer, and returns both """ 390 391 baseval = cty.c_uint() 392 ptrbaseval = cty.byref(baseval) 393 return baseval, ptrbaseval
394 395
396 -def make_long_and_pointer():
397 """ Makes a ctypes c_long and its pointer, and returns both """ 398 399 baseval = cty.c_long() 400 ptrbaseval = cty.byref(baseval) 401 return baseval, ptrbaseval
402 403
404 -def make_ulong_and_pointer():
405 """ Makes a ctypes c_ulong and its pointer, and returns both """ 406 407 baseval = cty.c_ulong() 408 ptrbaseval = cty.byref(baseval) 409 return baseval, ptrbaseval
410 411 make_Pixmap_and_pointer = make_ulong_and_pointer 412 make_FL_COLOR_and_pointer = make_ulong_and_pointer 413 414
415 -def make_float_and_pointer():
416 """ Makes a ctypes c_float and its pointer, and returns both """ 417 418 baseval = cty.c_float() 419 ptrbaseval = cty.byref(baseval) 420 return baseval, ptrbaseval
421 422
423 -def make_double_and_pointer():
424 """ Makes a ctypes c_double and its pointer, and returns both """ 425 426 baseval = cty.c_double() 427 ptrbaseval = cty.byref(baseval) 428 return baseval, ptrbaseval
429 430
431 -def check_admitted_listvalues(paramname, *valueslist):
432 """ Check if paramname value is valid in accordance to a list 433 of admissible values. 434 """ 435 436 if isinstance(valueslist, list): 437 if paramname not in valueslist: 438 raise XFormsTypeError("Parameter value must be included in " \ 439 "list %s." % valueslist)
440 441 442 # exported variables 443 FL_EVENT = (cty.POINTER(FL_OBJECT)).in_dll(load_so_libforms(), 'FL_EVENT') 444 fl_current_form = (cty.POINTER(FL_FORM)).in_dll(load_so_libforms(), \ 445 'fl_current_form') 446 fl_display = (cty.POINTER(Display)).in_dll(load_so_libforms(), 'fl_display') 447 fl_screen = (cty.c_int).in_dll(load_so_libforms(), 'fl_screen') 448 # root window 449 fl_root = (Window).in_dll(load_so_libforms(), 'fl_root') 450 # virtual root window 451 fl_vroot = (Window).in_dll(load_so_libforms(), 'fl_vroot') 452 # screen dimension in pixels 453 fl_scrh = (cty.c_int).in_dll(load_so_libforms(), 'fl_scrh') 454 fl_scrw = (cty.c_int).in_dll(load_so_libforms(), 'fl_scrw') 455 fl_vmode = (cty.c_int).in_dll(load_so_libforms(), 'fl_vmode') 456 fl_state = (cty.POINTER(FL_State)).in_dll(load_so_libforms(), 'fl_state') 457 fl_ul_magic_char = (STRING).in_dll(load_so_libforms(), 'fl_state') 458 459 460 ######################################## 461 # forms.h (Basic.h) 462 # Basic definitions and limits. 463 # Window system independent prototypes 464 # Modify with care 465 ######################################## 466 467
468 -def FL_IS_UPBOX(t):
469 if (t == FL_UP_BOX) or \ 470 (t == FL_OVAL3D_UPBOX) or \ 471 (t == FL_ROUNDED3D_UPBOX): 472 return True 473 else: 474 return False
475 476
477 -def FL_IS_DOWNBOX(t):
478 if (t == FL_DOWN_BOX) or \ 479 (t == FL_OVAL3D_DOWNBOX) or \ 480 (t == FL_ROUNDED3D_DOWNBOX): 481 return True 482 else: 483 return False
484 485
486 -def FL_TO_DOWNBOX(t):
487 if t == FL_UP_BOX: 488 t1 = FL_DOWN_BOX 489 elif t == FL_ROUNDED3D_UPBOX: 490 t1 = FL_ROUNDED3D_DOWNBOX 491 elif t == FL_OVAL3D_UPBOX: 492 t1 = FL_OVAL3D_DOWNBOX 493 else: 494 t1 = t 495 return t1
496 497
498 -def special_style(a):
499 if (a >= FL_SHADOW_STYLE) and \ 500 (a <= (FL_EMBOSSED_STYLE + FL_MAXFONTS)): 501 return True 502 else: 503 return False
504 505 506 507 508 # Macro for getting at the object handlers return value 509
510 -def fl_object_returned(pObject):
511 return pObject.contents.returned
512 513 514 # IO other than XEvent Q 515 516 FL_IO_CALLBACK = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 517
518 -def fl_add_io_callback(fd, mask, py_IoCallback, data):
519 """ 520 fl_add_io_callback(fd, mask, py_IoCallback, data) 521 522 Registers an input callback function when input is available from fd. 523 524 @param fd : a valid file descriptor in a *nix system 525 @param mask : under what circumstance the input callback should be 526 invoked (i.e. FL_READ, FL_WRITE or FL_EXCEPT) 527 @param py_IoCallback : python function to be invoked under mask 528 condition, fn(num, ptr_void) 529 @param data : argument to be passed to function 530 """ 531 532 _fl_add_io_callback = cfuncproto( 533 load_so_libforms(), "fl_add_io_callback", \ 534 None, [cty.c_int, cty.c_uint, FL_IO_CALLBACK, cty.c_void_p], \ 535 """void fl_add_io_callback(int fd, unsigned int mask, 536 FL_IO_CALLBACK callback, void * data) 537 """) 538 ifd = convert_to_int(fd) 539 uimask = convert_to_uint(mask) 540 c_IoCallback = FL_IO_CALLBACK(py_IoCallback) 541 pdata = cty.cast(data, cty.c_void_p) 542 keep_cfunc_refs(c_IoCallback, py_IoCallback) 543 keep_elem_refs(fd, ifd, mask, uimask, data, pdata) 544 _fl_add_io_callback(ifd, uimask, c_IoCallback, pdata)
545 546
547 -def fl_remove_io_callback(fd, mask, py_IoCallback):
548 """ 549 fl_remove_io_callback(fd, mask, py_IoCallback) 550 551 Removes the registered callback function when input is available 552 from fd. 553 554 @param fd : a valid file descriptor in a unix system 555 @param mask : under what circumstance the input callback should be 556 removed (i.e. xfc.FL_READ, xfc.FL_WRITE, xfc.FL_EXCEPT) 557 @param py_IoCallback : python function to be removed under mask 558 condition, fn(num, ptr_void) 559 """ 560 561 _fl_remove_io_callback = cfuncproto( 562 load_so_libforms(), "fl_remove_io_callback", \ 563 None, [cty.c_int, cty.c_uint, FL_IO_CALLBACK], \ 564 """void fl_remove_io_callback(int fd, unsigned int mask, 565 FL_IO_CALLBACK cb) 566 """) 567 check_admitted_listvalues(mask, ASYNCIO_list) 568 ifd = convert_to_int(fd) 569 uimask = convert_to_uint(mask) 570 c_IoCallback = FL_IO_CALLBACK(py_IoCallback) 571 keep_cfunc_refs(c_IoCallback, py_IoCallback) 572 keep_elem_refs(fd, ifd, mask, uimask) 573 _fl_remove_io_callback(ifd, uimask, c_IoCallback)
574 575 576 # signals 577 578 FL_SIGNAL_HANDLER = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 579
580 -def fl_add_signal_callback(sglnum, py_SignalHandler, data):
581 """ 582 fl_add_signal_callback(sglnum, py_SignalHandler, data) 583 584 Handles the receipt of a signal by registering a callback function 585 that gets called when a signal is caught (only 1 function per signal) 586 587 @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 588 @param py_SignalHandler : python function to be invoked after 589 catching the signal, fn(num, ptr_void) 590 @param data : argument to be passed to function 591 """ 592 593 _fl_add_signal_callback = cfuncproto( 594 load_so_libforms(), "fl_add_signal_callback", \ 595 None, [cty.c_int, FL_SIGNAL_HANDLER, cty.c_void_p], \ 596 """void fl_add_signal_callback(int s, FL_SIGNAL_HANDLER cb, 597 void * data) 598 """) 599 isglnum = convert_to_int(sglnum) 600 c_SignalHandler = FL_SIGNAL_HANDLER(py_SignalHandler) 601 pdata = cty.cast(data, cty.c_void_p) 602 keep_cfunc_refs(c_SignalHandler, py_SignalHandler) 603 keep_elem_refs(sglnum, isglnum, data, pdata) 604 _fl_add_signal_callback(isglnum, c_SignalHandler, pdata)
605 606
607 -def fl_remove_signal_callback(sglnum):
608 """ 609 fl_remove_signal_callback(sglnum) 610 611 Removes a previously registered callback function related to a signal. 612 613 @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 614 """ 615 616 _fl_remove_signal_callback = cfuncproto( 617 load_so_libforms(), "fl_remove_signal_callback", \ 618 None, [cty.c_int], \ 619 """void fl_remove_signal_callback(int s) 620 """) 621 isglnum = convert_to_int(sglnum) 622 keep_elem_refs(sglnum, isglnum) 623 _fl_remove_signal_callback(isglnum)
624 625
626 -def fl_signal_caught(sglnum):
627 """ 628 fl_signal_caught(sglnum) 629 630 Informs the main loop of the delivery of the signal signum, the signal 631 is received by the application program 632 633 @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 634 """ 635 636 _fl_signal_caught = cfuncproto( 637 load_so_libforms(), "fl_signal_caught", \ 638 None, [cty.c_int], \ 639 """void fl_signal_caught(int s) 640 """) 641 isglnum = convert_to_int(sglnum) 642 keep_elem_refs(sglnum, isglnum) 643 _fl_signal_caught(isglnum)
644 645
646 -def fl_app_signal_direct(flag):
647 """ 648 fl_app_signal_direct(flag) 649 650 Changes the default behavior of the built-in signal facilities (to 651 be called with a true value for flag prior to any use of 652 fl_add_signal_callback 653 654 @param flag : flag (0|1) 655 """ 656 657 _fl_app_signal_direct = cfuncproto( 658 load_so_libforms(), "fl_app_signal_direct", \ 659 None, [cty.c_int], \ 660 """void fl_app_signal_direct(int y) 661 """) 662 iflag = convert_to_int(flag) 663 keep_elem_refs(flag, iflag) 664 _fl_app_signal_direct(iflag)
665 666 667 # timeouts 668 669 FL_TIMEOUT_CALLBACK = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 670
671 -def fl_add_timeout(msec, py_TimeoutCallback, data):
672 """ 673 fl_add_timeout(msec, py_TimeoutCallback, data) -> timer ID 674 675 Adds a timeout callback after a specified elapsed time. 676 677 @param msec : time elapsed in milliseconds 678 @param py_TimeoutCallback : python function to be invoked after time, 679 fn(num, ptr_void) 680 @param data : argument to be passed to function 681 """ 682 683 _fl_add_timeout = cfuncproto( 684 load_so_libforms(), "fl_add_timeout", \ 685 cty.c_int, [cty.c_long, FL_TIMEOUT_CALLBACK, cty.c_void_p], \ 686 """int fl_add_timeout(long int msec, 687 FL_TIMEOUT_CALLBACK callback, void * data) 688 """) 689 lmsec = convert_to_long(msec) 690 pdata = cty.cast(data, cty.c_void_p) 691 c_TimeoutCallback = FL_TIMEOUT_CALLBACK(py_TimeoutCallback) 692 keep_cfunc_refs(c_TimeoutCallback, py_TimeoutCallback) 693 keep_elem_refs(msec, lmsec, data, pdata) 694 retval = _fl_add_timeout(lmsec, c_TimeoutCallback, pdata) 695 return retval
696 697
698 -def fl_remove_timeout(idnum):
699 """ 700 fl_remove_timeout(idnum) 701 702 Removes a timeout callback function (created with fl_add_timeout). 703 704 @param idnum : ID timeout number 705 """ 706 707 _fl_remove_timeout = cfuncproto( 708 load_so_libforms(), "fl_remove_timeout", \ 709 None, [cty.c_int], \ 710 """void fl_remove_timeout(int id) 711 """) 712 iidnum = convert_to_int(idnum) 713 keep_elem_refs(idnum, iidnum) 714 _fl_remove_timeout(iidnum)
715 716 717 # Basic public routine prototypes 718 719 #def fl_library_version(ver, rev) *API change*
720 -def fl_library_version():
721 """ 722 fl_library_version() -> version_rev ID, ver, rev 723 724 Returns consolidated version informations. 725 726 Returns: 727 <version_rev> : computed as 1000 * version + revision 728 <ver> : version (e.g. 1 in 1.x.yy) 729 <rev> : revision (e.g. 0 in x.0.yy) 730 """ 731 732 _fl_library_version = cfuncproto( 733 load_so_libforms(), "fl_library_version", \ 734 cty.c_int, [cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], \ 735 """int fl_library_version(int * ver, int * rev) 736 """) 737 ver, pver = make_int_and_pointer() 738 rev, prev = make_int_and_pointer() 739 keep_elem_refs(ver, rev, pver, prev) 740 retval = _fl_library_version(pver, prev) 741 return retval, ver, rev
742 743 744 # Generic routines that deal with FORMS 745
746 -def fl_bgn_form(formtype, w, h):
747 """ 748 fl_bgn_form(formtype, w, h) -> pForm 749 750 Starts the definition of a form call. 751 752 @param formtype : type of box that is used as a background 753 (e.g. FL_DOWN_BOX, FL_BORDER_BOX, FL_SHADOW_BOX, etc.) 754 @param w : width of the new form 755 @param h : height of the new form 756 """ 757 758 _fl_bgn_form = cfuncproto( 759 load_so_libforms(), "fl_bgn_form", \ 760 cty.POINTER(FL_FORM), [cty.c_int, FL_Coord, FL_Coord], \ 761 """FL_FORM * fl_bgn_form(int type, FL_Coord w, FL_Coord h) 762 """) 763 check_admitted_listvalues(formtype, BOXTYPE_list) 764 iformtype = convert_to_int(formtype) 765 iw = convert_to_FL_Coord(w) 766 ih = convert_to_FL_Coord(h) 767 keep_elem_refs(formtype, iformtype, w, iw, h, ih) 768 retval = _fl_bgn_form(iformtype, iw, ih) 769 return retval
770 771
772 -def fl_end_form():
773 """ 774 fl_end_form() 775 776 Ends the definition for a form call, after all required objects 777 have been added to a form call. 778 """ 779 780 _fl_end_form = cfuncproto( 781 load_so_libforms(), "fl_end_form", \ 782 None, [], \ 783 """void fl_end_form() 784 """) 785 _fl_end_form()
786 787
788 -def fl_do_forms():
789 """ 790 fl_do_forms() -> pObject 791 792 Starts the main loop of the program and returns only when the state 793 of an object changes that has no callback bound to it. 794 """ 795 796 _fl_do_forms = cfuncproto( 797 load_so_libforms(), "fl_do_forms", \ 798 cty.POINTER(FL_OBJECT), [], \ 799 """FL_OBJECT * fl_do_forms() 800 """) 801 retval = _fl_do_forms() 802 return retval
803 804
805 -def fl_check_forms():
806 """ 807 fl_check_forms() -> pObject 808 809 Returns None immediately unless the state of one of the object 810 (without a callback bound to it) changed. 811 """ 812 813 _fl_check_forms = cfuncproto( 814 load_so_libforms(), "fl_check_forms", \ 815 cty.POINTER(FL_OBJECT), [], \ 816 """FL_OBJECT * fl_check_forms() 817 """) 818 retval = _fl_check_forms() 819 return retval
820 821
822 -def fl_do_only_forms():
823 """ 824 fl_do_only_forms() -> pObject 825 826 Starts the main loop of the program and returns only when the state of 827 an object changes that has no callback bound to it. It does not 828 handle user events generated by application windows opened via 829 fl_winopen() or similar routines. 830 """ 831 832 _fl_do_only_forms = cfuncproto( 833 load_so_libforms(), "fl_do_only_forms", \ 834 cty.POINTER(FL_OBJECT), [], \ 835 """FL_OBJECT * fl_do_only_forms() 836 """) 837 retval = _fl_do_only_forms() 838 return retval
839 840
841 -def fl_check_only_forms():
842 """ 843 fl_check_only_forms() -> pObject 844 845 Returns None immediately unless the state of one of the object 846 (without a callback bound to it) changed. It does not handle user 847 events generated by application windows opened via fl_winopen() or 848 similar routines. 849 """ 850 851 _fl_check_only_forms = cfuncproto( 852 load_so_libforms(), "fl_check_only_forms", \ 853 cty.POINTER(FL_OBJECT), [], \ 854 """FL_OBJECT * fl_check_only_forms() 855 """) 856 retval = _fl_check_only_forms() 857 return retval
858 859
860 -def fl_freeze_form(pForm):
861 """ 862 fl_freeze_form(pForm) 863 864 It does not temporarily redraw a form while changes are being made, so 865 all changes made are instead buffered internally. 866 867 @param pForm : pointer to form not to be re-drawn temporarly 868 """ 869 870 _fl_freeze_form = cfuncproto( 871 load_so_libforms(), "fl_freeze_form", \ 872 None, [cty.POINTER(FL_FORM)], \ 873 """void fl_freeze_form(FL_FORM * form) 874 """) 875 keep_elem_refs(pForm) 876 _fl_freeze_form(pForm)
877 878
879 -def fl_set_focus_object(pForm, pObject):
880 """ 881 fl_set_focus_object(pForm, pObject) 882 883 Sets the input focus in form to object pObject. 884 885 @param pForm : pointer to form whose object has to be focused 886 @param pObject : pointer to object to be focused 887 """ 888 889 _fl_set_focus_object = cfuncproto( 890 load_so_libforms(), "fl_set_focus_object", \ 891 None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)], \ 892 """void fl_set_focus_object(FL_FORM * form, FL_OBJECT * obj) 893 """) 894 keep_elem_refs(pForm, pObject) 895 _fl_set_focus_object(pForm, pObject)
896 897 898 fl_set_object_focus = fl_set_focus_object 899 900
901 -def fl_get_focus_object(pForm):
902 """ 903 fl_get_focus_object(pForm) -> pObject 904 905 Obtains the object that has the focus on a form. 906 907 @param pForm : pointer to form that has a focused object 908 """ 909 910 _fl_get_focus_object = cfuncproto( 911 load_so_libforms(), "fl_get_focus_object", \ 912 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_FORM)], \ 913 """FL_OBJECT * fl_get_focus_object(FL_FORM * form) 914 """) 915 keep_elem_refs(pForm) 916 retval = _fl_get_focus_object(pForm) 917 return retval
918 919
920 -def fl_reset_focus_object(pObject):
921 """ 922 fl_reset_focus_object(pObject) 923 924 Override the FL_UNFOCUS event. 925 926 @param pObject : pointer to object towards applying event 927 """ 928 929 _fl_reset_focus_object = cfuncproto( 930 load_so_libforms(), "fl_reset_focus_object", \ 931 None, [cty.POINTER(FL_OBJECT)], \ 932 """void fl_reset_focus_object(FL_OBJECT * ob) 933 """) 934 keep_elem_refs(pObject) 935 _fl_reset_focus_object(pObject)
936 937 938 #already defined in xfdata 939 #FL_FORM_ATCLOSE = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_FORM), cty.c_void_p) 940
941 -def fl_set_form_atclose(pForm, py_FormAtclose, data):
942 """ 943 fl_set_form_atclose(pForm, py_FormAtclose, data) -> FormAtclose func. 944 945 Calls a callback function before closing the form. 946 947 @param pForm : pointer to form that receives the message 948 @param py_FormAtclose : python callback function to be called, 949 fn(pForm, ptr_void) -> num 950 @param data : argument to be passed to function 951 """ 952 953 _fl_set_form_atclose = cfuncproto( 954 load_so_libforms(), "fl_set_form_atclose", \ 955 FL_FORM_ATCLOSE, [cty.POINTER(FL_FORM), FL_FORM_ATCLOSE, 956 cty.c_void_p], \ 957 """FL_FORM_ATCLOSE fl_set_form_atclose(FL_FORM * form, 958 FL_FORM_ATCLOSE fmclose, void * data) 959 """) 960 c_FormAtclose = FL_FORM_ATCLOSE(py_FormAtclose) 961 pdata = cty.cast(data, cty.c_void_p) 962 keep_cfunc_refs(c_FormAtclose, py_FormAtclose) 963 keep_elem_refs(pForm, data, pdata) 964 retval = _fl_set_form_atclose(pForm, c_FormAtclose, pdata) 965 return retval
966 967
968 -def fl_set_atclose(py_FormAtclose, data):
969 """ 970 fl_set_atclose(py_FormAtclose, data) -> FormAtclose func. 971 972 Calls a callback function before terminating the application. 973 974 @param py_FormAtclose : callback function to be called, fn(pForm, 975 ptr_void) -> num 976 @param data : argument to be passed to function 977 """ 978 979 _fl_set_atclose = cfuncproto( 980 load_so_libforms(), "fl_set_atclose", \ 981 FL_FORM_ATCLOSE, [FL_FORM_ATCLOSE, cty.c_void_p], \ 982 """FL_FORM_ATCLOSE fl_set_atclose(FL_FORM_ATCLOSE fmclose, 983 void * data) 984 """) 985 c_FormAtclose = FL_FORM_ATCLOSE(py_FormAtclose) 986 pdata = cty.cast(data, cty.c_void_p) 987 keep_cfunc_refs(c_FormAtclose, py_FormAtclose) 988 keep_elem_refs(data, pdata) 989 retval = _fl_set_atclose(c_FormAtclose, pdata) 990 return retval
991 992 993 #already defined in xfdata 994 #FL_FORM_ATACTIVATE = cty.CFUNCTYPE(None, cty.POINTER(FL_FORM), cty.c_void_p) 995
996 -def fl_set_form_atactivate(pForm, py_FormAtactivate, data):
997 """ 998 fl_set_form_atactivate(pForm, py_FormAtactivate, data) -> FormAtactivate func. 999 1000 Register a callback that is called when activation status of a forms 1001 is enabled, 1002 1003 @param pForm : activated form 1004 @param py_FormAtactivate : python callback function called, fn(pForm, 1005 ptr_void) 1006 @param data : argument to be passed to function 1007 """ 1008 1009 _fl_set_form_atactivate = cfuncproto( 1010 load_so_libforms(), "fl_set_form_atactivate", \ 1011 FL_FORM_ATACTIVATE, [cty.POINTER(FL_FORM), FL_FORM_ATACTIVATE, 1012 cty.c_void_p], \ 1013 """FL_FORM_ATACTIVATE fl_set_form_atactivate(FL_FORM * form, 1014 FL_FORM_ATACTIVATE cb, void * data) 1015 """) 1016 c_FormAtactivate = FL_FORM_ATACTIVATE(py_FormAtactivate) 1017 pdata = cty.cast(data, cty.c_void_p) 1018 keep_cfunc_refs(c_FormAtactivate, py_FormAtactivate) 1019 keep_elem_refs(pForm, data, pdata) 1020 retval = _fl_set_form_atactivate(pForm, c_FormAtactivate, pdata) 1021 return retval
1022 1023 1024 #already defined in xfdata 1025 #FL_FORM_ATDEACTIVATE = cty.CFUNCTYPE(None, cty.POINTER(FL_FORM), cty.c_void_p) 1026
1027 -def fl_set_form_atdeactivate(pForm, py_FormAtdeactivate, data):
1028 """ 1029 fl_set_form_atdeactivate(pForm, py_FormAtdeactivate, data) -> FormAtdeactivate func. 1030 1031 Register a callback that is called when activation status of a forms 1032 is disabled. 1033 1034 @param pForm : pointer to de-activated form 1035 @param py_FormAtdeactivate : python callback function called, 1036 fn(pForm, ptr_void) 1037 @param data : argument to be passed to function 1038 """ 1039 1040 _fl_set_form_atdeactivate = cfuncproto( 1041 load_so_libforms(), "fl_set_form_atdeactivate", \ 1042 FL_FORM_ATDEACTIVATE, [cty.POINTER(FL_FORM), 1043 FL_FORM_ATDEACTIVATE, cty.c_void_p], \ 1044 """FL_FORM_ATDEACTIVATE fl_set_form_atdeactivate(FL_FORM * form, 1045 FL_FORM_ATDEACTIVATE cb, void * data) 1046 """) 1047 c_FormAtdeactivate = FL_FORM_ATDEACTIVATE(py_FormAtdeactivate) 1048 pdata = cty.cast(data, cty.c_void_p) 1049 keep_cfunc_refs(c_FormAtdeactivate, py_FormAtdeactivate) 1050 keep_elem_refs(pForm, data, pdata) 1051 retval = _fl_set_form_atdeactivate(pForm, c_FormAtdeactivate, pdata) 1052 return retval
1053 1054
1055 -def fl_unfreeze_form(pForm):
1056 """ 1057 fl_unfreeze_form(pForm) 1058 1059 All changes made in the meantime in a form are drawn at once, 1060 reverting previous freeze. 1061 1062 @param pForm : pointer to form to be re-drawn after freezing 1063 """ 1064 1065 _fl_unfreeze_form = cfuncproto( 1066 load_so_libforms(), "fl_unfreeze_form", \ 1067 None, [cty.POINTER(FL_FORM)], \ 1068 """void fl_unfreeze_form(FL_FORM * form) 1069 """) 1070 keep_elem_refs(pForm) 1071 _fl_unfreeze_form(pForm)
1072 1073
1074 -def fl_deactivate_form(pForm):
1075 """ 1076 fl_deactivate_form(pForm) 1077 1078 Deactivates form temporarily, without hiding it, but not allowing the 1079 user to interact with elements contained in form (buttons, etc.). 1080 1081 @param pForm : pointer to form to be de-activated 1082 """ 1083 1084 _fl_deactivate_form = cfuncproto( 1085 load_so_libforms(), "fl_deactivate_form", \ 1086 None, [cty.POINTER(FL_FORM)], \ 1087 """void fl_deactivate_form(FL_FORM * form) 1088 """) 1089 keep_elem_refs(pForm) 1090 _fl_deactivate_form(pForm)
1091 1092
1093 -def fl_activate_form(pForm):
1094 """ 1095 fl_activate_form(pForm) 1096 1097 (Re)activates form, allowing the user to interact again with elements 1098 contained in form (buttons, etc.). 1099 1100 @param pForm : pointer to form to be re-activated 1101 """ 1102 1103 _fl_activate_form = cfuncproto( 1104 load_so_libforms(), "fl_activate_form", \ 1105 None, [cty.POINTER(FL_FORM)], \ 1106 """void fl_activate_form(FL_FORM * form) 1107 """) 1108 keep_elem_refs(pForm) 1109 _fl_activate_form(pForm)
1110 1111
1112 -def fl_deactivate_all_forms():
1113 """ 1114 fl_deactivate_all_forms() 1115 1116 De-activates all current forms, forbidding any user interactions. 1117 """ 1118 1119 _fl_deactivate_all_forms = cfuncproto( 1120 load_so_libforms(), "fl_deactivate_all_forms", \ 1121 None, [], \ 1122 """void fl_deactivate_all_forms() 1123 """) 1124 _fl_deactivate_all_forms()
1125 1126
1127 -def fl_activate_all_forms():
1128 """ 1129 fl_activate_all_forms() 1130 1131 (Re)activates all current forms, allowing user interaction. 1132 """ 1133 1134 _fl_activate_all_forms = cfuncproto( 1135 load_so_libforms(), "fl_activate_all_forms", \ 1136 None, [], \ 1137 """void fl_activate_all_forms() 1138 """) 1139 _fl_activate_all_forms()
1140 1141
1142 -def fl_freeze_all_forms():
1143 """ 1144 fl_freeze_all_forms() 1145 1146 It does not temporarily redraw all current forms while changes are 1147 being made, so all changes made are instead buffered internally. 1148 """ 1149 1150 _fl_freeze_all_forms = cfuncproto( 1151 load_so_libforms(), "fl_freeze_all_forms", \ 1152 None, [], \ 1153 """void fl_freeze_all_forms() 1154 """) 1155 _fl_freeze_all_forms()
1156 1157
1158 -def fl_unfreeze_all_forms():
1159 """ 1160 fl_unfreeze_all_forms() 1161 1162 All changes made in the meantime in all current forms are drawn at 1163 once, reverting previous freeze. 1164 """ 1165 1166 _fl_unfreeze_all_forms = cfuncproto( 1167 load_so_libforms(), "fl_unfreeze_all_forms", \ 1168 None, [], \ 1169 """void fl_unfreeze_all_forms() 1170 """) 1171 _fl_unfreeze_all_forms()
1172 1173
1174 -def fl_scale_form(pForm, xsc, ysc):
1175 """ 1176 fl_scale_form(pForm, xsc, ysc) 1177 1178 Scales a form and the objects on it in size and position, indicating 1179 a scaling factor in x- and y-direction with respect to the current 1180 size, and reshapes the window. 1181 1182 @param pForm : pointer to form to be scaled 1183 @param xsc : scaling factor in horizontal direction 1184 @param ysc : scaling factor in vertical direction 1185 """ 1186 1187 _fl_scale_form = cfuncproto( 1188 load_so_libforms(), "fl_scale_form", \ 1189 None, [cty.POINTER(FL_FORM), cty.c_double, cty.c_double], \ 1190 """void fl_scale_form(FL_FORM * form, double xsc, double ysc) 1191 """) 1192 fxsc = convert_to_double(xsc) 1193 fysc = convert_to_double(ysc) 1194 keep_elem_refs(pForm, xsc, fxsc, ysc, fysc) 1195 _fl_scale_form(pForm, fxsc, fysc)
1196 1197
1198 -def fl_set_form_position(pForm, x, y):
1199 """ 1200 fl_set_form_position(pForm, x, y) 1201 1202 Sets position of form, when placing a form on the screen with 1203 FL_PLACE_GEOMETRY as place argument. 1204 1205 @param pForm : pointer to form whose position is to be set 1206 @param x : horizontal position 1207 @param y : vertical position 1208 """ 1209 1210 _fl_set_form_position = cfuncproto( 1211 load_so_libforms(), "fl_set_form_position", \ 1212 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 1213 """void fl_set_form_position(FL_FORM * form, FL_Coord x, 1214 FL_Coord y) 1215 """) 1216 ix = convert_to_FL_Coord(x) 1217 iy = convert_to_FL_Coord(y) 1218 keep_elem_refs(pForm, x, ix, y, iy) 1219 _fl_set_form_position(pForm, ix, iy)
1220 1221
1222 -def fl_set_form_title(pForm, name):
1223 """ 1224 fl_set_form_title(pForm, name) 1225 1226 Changes the form title (and the icon name) after it is shown. 1227 1228 @param pForm : pointer to form whose title has to be changed 1229 @param name : new name for the form 1230 """ 1231 1232 _fl_set_form_title = cfuncproto( 1233 load_so_libforms(), "fl_set_form_title", \ 1234 None, [cty.POINTER(FL_FORM), STRING], \ 1235 """void fl_set_form_title(FL_FORM * form, const char * name) 1236 """) 1237 sname = convert_to_string(name) 1238 keep_elem_refs(pForm, name, sname) 1239 _fl_set_form_title(pForm, sname)
1240 1241
1242 -def fl_set_app_mainform(pForm):
1243 """ fl_set_app_mainform(pForm) 1244 """ 1245 1246 _fl_set_app_mainform = cfuncproto( 1247 load_so_libforms(), "fl_set_app_mainform", 1248 None, [cty.POINTER(FL_FORM)], \ 1249 """void fl_set_app_mainform(FL_FORM * form) 1250 """) 1251 keep_elem_refs(pForm) 1252 _fl_set_app_mainform(pForm)
1253 1254
1255 -def fl_get_app_mainform():
1256 """ fl_get_app_mainform() -> pForm 1257 """ 1258 1259 _fl_get_app_mainform = cfuncproto( 1260 load_so_libforms(), "fl_get_app_mainform", 1261 cty.POINTER(FL_FORM), [], \ 1262 """FL_FORM * fl_get_app_mainform() 1263 """) 1264 retval = _fl_get_app_mainform() 1265 return retval
1266 1267
1268 -def fl_set_app_nomainform(flag):
1269 """ fl_set_app_nomainform(flag) 1270 """ 1271 1272 _fl_set_app_nomainform = cfuncproto( 1273 load_so_libforms(), "fl_set_app_nomainform", 1274 None, [cty.c_int], \ 1275 """void fl_set_app_nomainform(int flag) 1276 """) 1277 iflag = convert_to_int(flag) 1278 keep_elem_refs(flag, iflag) 1279 _fl_set_app_nomainform(iflag)
1280 1281 1282 #already defined in xfdata 1283 #FL_FORMCALLBACKPTR = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_void_p) 1284
1285 -def fl_set_form_callback(pForm, py_FormCallbackPtr, data):
1286 """ fl_set_form_callback(pForm, py_FormCallbackPtr, data) 1287 1288 Sets the callback routine for the form. 1289 1290 @param pForm : pointer to form 1291 @param py_FormCallbackPtr : python callback to be set, 1292 fn(pObject, ptr_void) 1293 @param data : argument to be passed to function 1294 """ 1295 1296 _fl_set_form_callback = cfuncproto( 1297 load_so_libforms(), "fl_set_form_callback", \ 1298 None, [cty.POINTER(FL_FORM), FL_FORMCALLBACKPTR, cty.c_void_p], \ 1299 """void fl_set_form_callback(FL_FORM * form, 1300 FL_FORMCALLBACKPTR callback, void * d) 1301 """) 1302 c_FormCallbackPtr = FL_FORMCALLBACKPTR(py_FormCallbackPtr) 1303 pdata = cty.cast(data, cty.c_void_p) 1304 keep_cfunc_refs(c_FormCallbackPtr, py_FormCallbackPtr) 1305 keep_elem_refs(pForm, data, pdata) 1306 _fl_set_form_callback(pForm, c_FormCallbackPtr, pdata)
1307 1308 1309 fl_set_form_call_back = fl_set_form_callback 1310 1311
1312 -def fl_set_form_size(pForm, w, h):
1313 """ 1314 fl_set_form_size(pForm, w, h) 1315 1316 Sets the size of form. 1317 1318 @param pForm : pointer to form 1319 @param w : width of form 1320 @param h : height of form 1321 """ 1322 1323 _fl_set_form_size = cfuncproto( 1324 load_so_libforms(), "fl_set_form_size", \ 1325 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 1326 """void fl_set_form_size(FL_FORM * form, FL_Coord w, FL_Coord h) 1327 """) 1328 iw = convert_to_FL_Coord(w) 1329 ih = convert_to_FL_Coord(h) 1330 keep_elem_refs(pForm, w, iw, h, ih) 1331 _fl_set_form_size(pForm, iw, ih)
1332 1333
1334 -def fl_set_form_hotspot(pForm, x, y):
1335 """ 1336 fl_set_form_hotspot(pForm, x, y) 1337 1338 Sets the position of the hotspot of a form. 1339 1340 @param pForm : pointer to form 1341 @param x : horizontal position 1342 @param y : vertical position 1343 """ 1344 1345 _fl_set_form_hotspot = cfuncproto( 1346 load_so_libforms(), "fl_set_form_hotspot", \ 1347 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 1348 """void fl_set_form_hotspot(FL_FORM * form, FL_Coord x, 1349 FL_Coord y) 1350 """) 1351 ix = convert_to_FL_Coord(x) 1352 iy = convert_to_FL_Coord(y) 1353 keep_elem_refs(pForm, x, ix, y, iy) 1354 _fl_set_form_hotspot(pForm, ix, iy)
1355 1356
1357 -def fl_set_form_hotobject(pForm, pObject):
1358 """ 1359 fl_set_form_hotobject(pForm, pObject) 1360 1361 @param pForm : pointer to form 1362 @param pObject : pointer to object 1363 """ 1364 1365 _fl_set_form_hotobject = cfuncproto( 1366 load_so_libforms(), "fl_set_form_hotobject", \ 1367 None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)], \ 1368 """void fl_set_form_hotobject(FL_FORM * form, FL_OBJECT * ob) 1369 """) 1370 keep_elem_refs(pForm, pObject) 1371 _fl_set_form_hotobject(pForm, pObject)
1372 1373
1374 -def fl_set_form_minsize(pForm, w, h):
1375 """ 1376 fl_set_form_minsize(pForm, w, h) 1377 1378 @param pForm : pointer to form 1379 @param w : width of form 1380 @param h : height of form 1381 """ 1382 1383 _fl_set_form_minsize = cfuncproto( 1384 load_so_libforms(), "fl_set_form_minsize", \ 1385 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 1386 """void fl_set_form_minsize(FL_FORM * form, FL_Coord w, FL_Coord h) 1387 """) 1388 iw = convert_to_FL_Coord(w) 1389 ih = convert_to_FL_Coord(h) 1390 keep_elem_refs(pForm, w, iw, h, ih) 1391 _fl_set_form_minsize(pForm, iw, ih)
1392 1393
1394 -def fl_set_form_maxsize(pForm, w, h):
1395 """ 1396 fl_set_form_maxsize(pForm, w, h) 1397 1398 @param pForm : pointer to form 1399 @param w : width of form 1400 @param h : height of form 1401 """ 1402 1403 _fl_set_form_maxsize = cfuncproto( 1404 load_so_libforms(), "fl_set_form_maxsize", \ 1405 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 1406 """void fl_set_form_maxsize(FL_FORM * form, FL_Coord w, FL_Coord h) 1407 """) 1408 iw = convert_to_FL_Coord(w) 1409 ih = convert_to_FL_Coord(h) 1410 keep_elem_refs(pForm, w, iw, h, ih) 1411 _fl_set_form_maxsize(pForm, iw, ih)
1412 1413
1414 -def fl_set_form_event_cmask(pForm, cmask):
1415 """ 1416 fl_set_form_event_cmask(pForm, cmask) 1417 1418 @param pForm : pointer to form 1419 @param cmask : compress mask for form 1420 """ 1421 1422 _fl_set_form_event_cmask = cfuncproto( 1423 load_so_libforms(), "fl_set_form_event_cmask", \ 1424 None, [cty.POINTER(FL_FORM), cty.c_ulong], \ 1425 """void fl_set_form_event_cmask(FL_FORM * form, 1426 long unsigned int cmask) 1427 """) 1428 ulcmask = convert_to_ulong(cmask) 1429 keep_elem_refs(pForm, cmask, ulcmask) 1430 _fl_set_form_event_cmask(pForm, ulcmask)
1431 1432
1433 -def fl_get_form_event_cmask(pForm):
1434 """ 1435 fl_get_form_event_cmask(pForm) -> compress mask ID 1436 1437 Returns event compress mask for form. 1438 1439 @param pForm : pointer to form 1440 """ 1441 1442 _fl_get_form_event_cmask = cfuncproto( 1443 load_so_libforms(), "fl_get_form_event_cmask", \ 1444 cty.c_ulong, [cty.POINTER(FL_FORM)], \ 1445 """long unsigned int fl_get_form_event_cmask(FL_FORM * form) 1446 """) 1447 keep_elem_refs(pForm) 1448 retval = _fl_get_form_event_cmask(pForm) 1449 return retval
1450 1451 1452 # alert until upstream bugfix
1453 -def fl_set_form_geometry(pForm, x, y, w, h):
1454 """ 1455 fl_set_form_geometry(pForm, x, y, w, h) 1456 1457 @param pForm : pointer to form 1458 @param x : horizontal position 1459 @param y : vertical position 1460 @param w : width of form 1461 @param h : height of form 1462 """ 1463 1464 _fl_set_form_geometry = cfuncproto( 1465 load_so_libforms(), "fl_set_form_geometry", \ 1466 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord, 1467 FL_Coord, FL_Coord], \ 1468 """void fl_set_form_geometry(FL_FORM * form, FL_Coord x, 1469 FL_Coord y, FL_Coord w, FL_Coord h) 1470 """) 1471 ix = convert_to_FL_Coord(x) 1472 iy = convert_to_FL_Coord(y) 1473 iw = convert_to_FL_Coord(w) 1474 ih = convert_to_FL_Coord(h) 1475 keep_elem_refs(pForm, x, ix, y, iy, w, iw, h, ih) 1476 _fl_set_form_geometry(pForm, ix, iy, iw, ih)
1477 1478 1479 fl_set_initial_placement = fl_set_form_geometry 1480 1481
1482 -def fl_show_form(pForm, place, border, title):
1483 """ 1484 fl_show_form(pForm, place, border, title) -> window id 1485 1486 Shows the form. 1487 1488 @param pForm : pointer to form 1489 @param place : where form has to be placed 1490 @param border : type of window manager decoration 1491 @param title : title of form 1492 """ 1493 1494 _fl_show_form = cfuncproto( 1495 load_so_libforms(), "fl_show_form", 1496 Window, [cty.POINTER(FL_FORM), cty.c_int, cty.c_int, STRING], \ 1497 """Window fl_show_form(FL_FORM * form, int place, int border, 1498 const char * name) 1499 """) 1500 check_admitted_listvalues(place, PLACE_list) 1501 check_admitted_listvalues(border, DECORATION_list) 1502 iplace = convert_to_int(place) 1503 iborder = convert_to_int(border) 1504 stitle = convert_to_string(title) 1505 keep_elem_refs(pForm, place, iplace, border, iborder, title, stitle) 1506 retval = _fl_show_form(pForm, iplace, iborder, stitle) 1507 return retval
1508 1509
1510 -def fl_hide_form(pForm):
1511 """ 1512 fl_hide_form(pForm) 1513 1514 Hides the form. 1515 1516 @param pForm : pointer to form 1517 """ 1518 1519 _fl_hide_form = cfuncproto( 1520 load_so_libforms(), "fl_hide_form", 1521 None, [cty.POINTER(FL_FORM)], \ 1522 """void fl_hide_form(FL_FORM * form) 1523 """) 1524 keep_elem_refs(pForm) 1525 _fl_hide_form(pForm)
1526 1527
1528 -def fl_free_form(pForm):
1529 """ 1530 fl_free_form(pForm) 1531 1532 Frees the memory used by a form together with all its objects. 1533 1534 @param pForm : pointer to form to be freed 1535 """ 1536 1537 _fl_free_form = cfuncproto( 1538 load_so_libforms(), "fl_free_form", 1539 None, [cty.POINTER(FL_FORM)], \ 1540 """void fl_free_form(FL_FORM * form) 1541 """) 1542 keep_elem_refs(pForm) 1543 _fl_free_form(pForm)
1544 1545
1546 -def fl_redraw_form(pForm):
1547 """ 1548 fl_redraw_form(pForm) 1549 1550 Draws a form. 1551 1552 @param pForm : pointer to form 1553 """ 1554 1555 _fl_redraw_form = cfuncproto( 1556 load_so_libforms(), "fl_redraw_form", 1557 None, [cty.POINTER(FL_FORM)], \ 1558 """void fl_redraw_form(FL_FORM * form) 1559 """) 1560 keep_elem_refs(pForm) 1561 _fl_redraw_form(pForm)
1562 1563
1564 -def fl_set_form_dblbuffer(pForm, y):
1565 """ 1566 fl_set_form_dblbuffer(pForm, y) 1567 1568 @param pForm : pointer to form 1569 @param y : flag (0|1) for disabling/enabling doublebuffer 1570 """ 1571 1572 _fl_set_form_dblbuffer = cfuncproto( 1573 load_so_libforms(), "fl_set_form_dblbuffer", \ 1574 None, [cty.POINTER(FL_FORM), cty.c_int], \ 1575 """void fl_set_form_dblbuffer(FL_FORM * form, int y) 1576 """) 1577 iy = convert_to_int(y) 1578 keep_elem_refs(pForm, y, iy) 1579 _fl_set_form_dblbuffer(pForm, iy)
1580 1581
1582 -def fl_prepare_form_window(pForm, place, border, name):
1583 """ 1584 fl_prepare_form_window(pForm, place, border, name) -> window ID 1585 1586 Displays a particular form, returns its window handle. 1587 1588 @param pForm : pointer to form 1589 @param place : where has to be placed 1590 @param border : window manager decoration 1591 @param name : title of form 1592 """ 1593 1594 _fl_prepare_form_window = cfuncproto( 1595 load_so_libforms(), "fl_prepare_form_window", \ 1596 Window, [cty.POINTER(FL_FORM), cty.c_int, cty.c_int, STRING], \ 1597 """Window fl_prepare_form_window(FL_FORM * form, int place, 1598 int border, const char * name) 1599 """) 1600 iplace = convert_to_int(place) 1601 iborder = convert_to_int(border) 1602 sname = convert_to_string(name) 1603 keep_elem_refs(pForm, place, iplace, border, iborder, name, sname) 1604 retval = _fl_prepare_form_window(pForm, iplace, iborder, sname) 1605 return retval
1606 1607
1608 -def fl_show_form_window(pForm):
1609 """ 1610 fl_show_form_window(pForm) -> window ID 1611 1612 @param pForm : pointer to form 1613 """ 1614 1615 _fl_show_form_window = cfuncproto( 1616 load_so_libforms(), "fl_show_form_window", \ 1617 Window, [cty.POINTER(FL_FORM)], \ 1618 """Window fl_show_form_window(FL_FORM * form) 1619 """) 1620 keep_elem_refs(pForm) 1621 retval = _fl_show_form_window(pForm) 1622 return retval
1623 1624
1625 -def fl_adjust_form_size(pForm):
1626 """ 1627 fl_adjust_form_size(pForm) -> max_factor id 1628 1629 Similar to fl_fit_object_label, but will do it for all objects and 1630 has a smaller threshold. Mainly intended for compensation for font 1631 size variations. 1632 1633 @param pForm : pointer to form 1634 """ 1635 1636 _fl_adjust_form_size = cfuncproto( 1637 load_so_libforms(), "fl_adjust_form_size", \ 1638 cty.c_double, [cty.POINTER(FL_FORM)], \ 1639 """double fl_adjust_form_size(FL_FORM * form) 1640 """) 1641 keep_elem_refs(pForm) 1642 retval = _fl_adjust_form_size(pForm) 1643 return retval
1644 1645
1646 -def fl_form_is_visible(pForm):
1647 """ 1648 fl_form_is_visible(pForm) -> state id 1649 1650 Returns if form is visible. 1651 1652 @param pForm : pointer to form 1653 """ 1654 1655 _fl_form_is_visible = cfuncproto( 1656 load_so_libforms(), "fl_form_is_visible", \ 1657 cty.c_int, [cty.POINTER(FL_FORM)], \ 1658 """int fl_form_is_visible(FL_FORM * form) 1659 """) 1660 keep_elem_refs(pForm) 1661 retval = _fl_form_is_visible(pForm) 1662 return retval
1663 1664
1665 -def fl_form_is_iconified(pForm):
1666 """ 1667 fl_form_is_iconified(pForm) -> state id 1668 1669 Returns if a forms window is in iconified state. 1670 1671 @param pForm : pointer to form 1672 """ 1673 1674 _fl_form_is_iconified = cfuncproto( 1675 load_so_libforms(), "fl_form_is_iconified", \ 1676 cty.c_int, [cty.POINTER(FL_FORM)], \ 1677 """int fl_form_is_iconified(FL_FORM * form) 1678 """) 1679 keep_elem_refs(pForm) 1680 retval = _fl_form_is_iconified(pForm) 1681 return retval
1682 1683 1684 #already defined in xfdata 1685 #FL_RAW_CALLBACK = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_FORM), cty.c_void_p) 1686
1687 -def fl_register_raw_callback(pForm, mask, py_RawCallback):
1688 """ 1689 fl_register_raw_callback(pForm, mask, py_RawCallback) -> old raw_callback func. 1690 1691 Register pre-emptive event handlers. 1692 1693 @param pForm : pointer to form 1694 @param mask : key/button/window event mask (press, release, motion, 1695 enter, leave etc..) 1696 @param py_RawCallback : python callback function, 1697 fn(pForm, ptr_void) -> num 1698 """ 1699 1700 _fl_register_raw_callback = cfuncproto( 1701 load_so_libforms(), "fl_register_raw_callback", \ 1702 FL_RAW_CALLBACK, [cty.POINTER(FL_FORM), cty.c_ulong, 1703 FL_RAW_CALLBACK], \ 1704 """FL_RAW_CALLBACK fl_register_raw_callback(FL_FORM * form, 1705 long unsigned int mask, FL_RAW_CALLBACK rcb) 1706 """) 1707 ulmask = convert_to_ulong(mask) 1708 c_RawCallback = FL_RAW_CALLBACK(py_RawCallback) 1709 keep_cfunc_refs(c_RawCallback, py_RawCallback) 1710 keep_elem_refs(pForm, mask, ulmask) 1711 retval = _fl_register_raw_callback(pForm, ulmask, c_RawCallback) 1712 return retval
1713 1714 1715 fl_register_call_back = fl_register_raw_callback 1716 1717
1718 -def fl_bgn_group():
1719 """ 1720 fl_bgn_group() -> pObject 1721 1722 Starts a group definition. 1723 """ 1724 1725 _fl_bgn_group = cfuncproto( 1726 load_so_libforms(), "fl_bgn_group", \ 1727 cty.POINTER(FL_OBJECT), [], \ 1728 """FL_OBJECT * fl_bgn_group() 1729 """) 1730 retval = _fl_bgn_group() 1731 return retval
1732 1733
1734 -def fl_end_group():
1735 """ 1736 fl_end_group() 1737 1738 Ends a group definition. 1739 """ 1740 1741 _fl_end_group = cfuncproto( 1742 load_so_libforms(), "fl_end_group", \ 1743 None, [], \ 1744 """void fl_end_group() 1745 """) 1746 _fl_end_group()
1747 1748
1749 -def fl_addto_group(pGroup):
1750 """ 1751 fl_addto_group(pGroup) -> pForm 1752 1753 Reopens a group to allow addition of further objects. 1754 1755 @param pGroup : pointer to group object to reopen 1756 """ 1757 1758 _fl_addto_group = cfuncproto( 1759 load_so_libforms(), "fl_addto_group", \ 1760 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], \ 1761 """FL_OBJECT * fl_addto_group(FL_OBJECT * group) 1762 """) 1763 keep_elem_refs(pGroup) 1764 retval = _fl_addto_group(pGroup) 1765 return retval
1766 1767 1768 # Routines that deal with FL_OBJECTS 1769 1770
1771 -def fl_get_object_objclass(pObject):
1772 """ 1773 fl_get_object_objclass(pObject) -> objclass id 1774 1775 Return the objclass of an object. 1776 1777 @param pObject : pointer to object 1778 """ 1779 1780 _fl_get_object_objclass = cfuncproto( 1781 load_so_libforms(), "fl_get_object_obclass", \ 1782 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 1783 """int fl_get_object_objclass(FL_OBJECT * obj) 1784 """) 1785 keep_elem_refs(pObject) 1786 retval = _fl_get_object_objclass(pObject) 1787 return retval
1788 1789
1790 -def fl_get_object_type(pObject):
1791 """ 1792 fl_get_object_type(pObject) -> type id 1793 1794 Return the type of an object. 1795 1796 @param pObject : pointer to object 1797 """ 1798 1799 _fl_get_object_type = cfuncproto( 1800 load_so_libforms(), "fl_get_object_type", \ 1801 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 1802 """int fl_get_object_type(FL_OBJECT * obj) 1803 """) 1804 keep_elem_refs(pObject) 1805 retval = _fl_get_object_type(pObject) 1806 return retval
1807 1808
1809 -def fl_set_object_boxtype(pObject, boxtype):
1810 """ 1811 fl_set_object_boxtype(pObject, boxtype) 1812 1813 Sets the type of box of an object. 1814 1815 @param pObject : pointer to object 1816 @param boxtype : type of the box 1817 """ 1818 1819 _fl_set_object_boxtype = cfuncproto( 1820 load_so_libforms(), "fl_set_object_boxtype", \ 1821 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 1822 """void fl_set_object_boxtype(FL_OBJECT * ob, int boxtype) 1823 """) 1824 check_admitted_listvalues(boxtype, BOXTYPE_list) 1825 iboxtype = convert_to_int(boxtype) 1826 keep_elem_refs(pObject, boxtype, iboxtype) 1827 _fl_set_object_boxtype(pObject, iboxtype)
1828 1829
1830 -def fl_get_object_boxtype(pObject):
1831 """ 1832 fl_get_object_boxtype(pObject) -> boxtype id 1833 1834 Return the boxtype of an object. 1835 1836 @param pObject : pointer to object 1837 """ 1838 1839 _fl_get_object_boxtype = cfuncproto( 1840 load_so_libforms(), "fl_get_object_boxtype", \ 1841 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 1842 """int fl_get_object_boxtype(FL_OBJECT * obj) 1843 """) 1844 keep_elem_refs(pObject) 1845 retval = _fl_get_object_boxtype(pObject) 1846 return retval
1847 1848
1849 -def fl_set_object_bw(pObject, bw):
1850 """ 1851 fl_set_object_bw(pObject, bw) 1852 1853 Sets the borderwidth of an object. 1854 1855 @param pObject : pointer to object 1856 @param bw : borderwidth of object 1857 """ 1858 1859 _fl_set_object_bw = cfuncproto( 1860 load_so_libforms(), "fl_set_object_bw", \ 1861 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 1862 """void fl_set_object_bw(FL_OBJECT * ob, int bw) 1863 """) 1864 ibw = convert_to_int(bw) 1865 keep_elem_refs(pObject, bw, ibw) 1866 _fl_set_object_bw(pObject, ibw)
1867 1868 1869 #def fl_get_object_bw(pObject, bw) *API change*
1870 -def fl_get_object_bw(pObject):
1871 """ 1872 fl_get_object_bw(pObject) -> bw 1873 1874 Returns the borderwidth of an object. 1875 1876 @param pObject : pointer to object 1877 """ 1878 1879 _fl_get_object_bw = cfuncproto( 1880 load_so_libforms(), "fl_get_object_bw", \ 1881 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], \ 1882 """void fl_get_object_bw(FL_OBJECT * ob, int * bw) 1883 """) 1884 bw, pbw = make_int_and_pointer() 1885 keep_elem_refs(pObject, bw, pbw) 1886 _fl_get_object_bw(pObject, pbw) 1887 return bw
1888 1889
1890 -def fl_set_object_resize(pObject, what):
1891 """ 1892 fl_set_object_resize(pObject, what) 1893 1894 Sets the resize property of an object. 1895 1896 @param pObject : pointer to object 1897 @param what : resize property 1898 """ 1899 1900 _fl_set_object_resize = cfuncproto( 1901 load_so_libforms(), "fl_set_object_resize", \ 1902 None, [cty.POINTER(FL_OBJECT), cty.c_uint], \ 1903 """void fl_set_object_resize(FL_OBJECT * ob, unsigned int what) 1904 """) 1905 uiwhat = convert_to_uint(what) 1906 keep_elem_refs(pObject, what, uiwhat) 1907 _fl_set_object_resize(pObject, uiwhat)
1908 1909 1910 #def fl_get_object_resize(pObject, what) *API change*
1911 -def fl_get_object_resize(pObject):
1912 """ 1913 fl_get_object_resize(pObject) -> what 1914 1915 Returns the resize property of an object. 1916 1917 @param pObject : pointer to object 1918 """ 1919 1920 _fl_get_object_resize = cfuncproto( 1921 load_so_libforms(), "fl_get_object_resize", \ 1922 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint)], \ 1923 """void fl_get_object_resize(FL_OBJECT * ob, unsigned int * what) 1924 """) 1925 what, pwhat = make_uint_and_pointer() 1926 keep_elem_refs(pObject, what, pwhat) 1927 _fl_get_object_resize(pObject, pwhat) 1928 return what
1929 1930
1931 -def fl_set_object_gravity(pObject, nw, se):
1932 """ 1933 fl_set_object_gravity(pObject, nw, se) 1934 1935 Sets the gravity properties of an object. 1936 1937 @param pObject : pointer to object 1938 @param nw : gravity property for NorthWest 1939 @param se : gravity property for SouthEast 1940 """ 1941 1942 _fl_set_object_gravity = cfuncproto( 1943 load_so_libforms(), "fl_set_object_gravity", \ 1944 None, [cty.POINTER(FL_OBJECT), cty.c_uint, cty.c_uint], \ 1945 """void fl_set_object_gravity(FL_OBJECT * ob, unsigned int nw, 1946 unsigned int se) 1947 """) 1948 uinw = convert_to_uint(nw) 1949 uise = convert_to_uint(se) 1950 keep_elem_refs(pObject, nw, uinw, se, uise) 1951 _fl_set_object_gravity(pObject, uinw, uise)
1952 1953 1954 #def fl_get_object_gravity(pObject, nw, se) *API change*
1955 -def fl_get_object_gravity(pObject):
1956 """ 1957 fl_get_object_gravity(pObject) -> nw, se 1958 1959 Returns the gravity properties of an object. 1960 1961 @param pObject : pointer to object 1962 """ 1963 1964 _fl_get_object_gravity = cfuncproto( 1965 load_so_libforms(), "fl_get_object_gravity", \ 1966 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint), 1967 cty.POINTER(cty.c_uint)], \ 1968 """void fl_get_object_gravity(FL_OBJECT * ob, unsigned int * nw, 1969 unsigned int * se) 1970 """) 1971 nw, pnw = make_uint_and_pointer() 1972 se, pse = make_uint_and_pointer() 1973 keep_elem_refs(pObject, nw, se, pnw, pse) 1974 _fl_get_object_gravity(pObject, pnw, pse) 1975 return nw, se
1976 1977
1978 -def fl_set_object_lsize(pObject, lsize):
1979 """ 1980 fl_set_object_lsize(pObject, lsize) 1981 1982 Sets the label size of an object. 1983 1984 @param pObject : pointer to object 1985 @param lsize : label size 1986 """ 1987 1988 _fl_set_object_lsize = cfuncproto( 1989 load_so_libforms(), "fl_set_object_lsize", \ 1990 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 1991 """void fl_set_object_lsize(FL_OBJECT * ob, int lsize) 1992 """) 1993 ilsize = convert_to_int(lsize) 1994 keep_elem_refs(pObject, lsize, ilsize) 1995 _fl_set_object_lsize(pObject, ilsize)
1996 1997
1998 -def fl_get_object_lsize(pObject):
1999 """ 2000 fl_get_object_lsize(pObject) -> lsize num. 2001 2002 Returns the label size of an object. 2003 2004 @param pObject : pointer to object 2005 """ 2006 2007 _fl_get_object_lsize = cfuncproto( 2008 load_so_libforms(), "fl_get_object_lsize", \ 2009 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 2010 """int fl_get_object_lsize(FL_OBJECT * obj) 2011 """) 2012 keep_elem_refs(pObject) 2013 retval = _fl_get_object_lsize(pObject) 2014 return retval
2015 2016
2017 -def fl_set_object_lstyle(pObject, lstyle):
2018 """ 2019 fl_set_object_lstyle(pObject, lstyle) 2020 2021 Sets the label style of an object. 2022 2023 @param pObject : pointer to object 2024 @param lstyle : label style 2025 """ 2026 2027 _fl_set_object_lstyle = cfuncproto( 2028 load_so_libforms(), "fl_set_object_lstyle", \ 2029 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2030 """void fl_set_object_lstyle(FL_OBJECT * ob, int lstyle) 2031 """) 2032 check_admitted_listvalues(lstyle, TEXTSTYLE_list) 2033 ilstyle = convert_to_int(lstyle) 2034 keep_elem_refs(pObject, lstyle, ilstyle) 2035 _fl_set_object_lstyle(pObject, ilstyle)
2036 2037
2038 -def fl_get_object_lstyle(pObject):
2039 """ 2040 fl_get_object_lstyle(pObject) -> lstyle num. 2041 2042 Returns the label style of an object. 2043 2044 @param pObject : pointer to object 2045 """ 2046 2047 _fl_get_object_lstyle = cfuncproto( 2048 load_so_libforms(), "fl_get_object_lstyle", \ 2049 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 2050 """int fl_get_object_lstyle(FL_OBJECT * obj) 2051 """) 2052 keep_elem_refs(pObject) 2053 retval = _fl_get_object_lstyle(pObject) 2054 return retval
2055 2056
2057 -def fl_set_object_lcol(pObject, lcolr):
2058 """ 2059 fl_set_object_lcol(pObject, lcolr) 2060 2061 Sets the label color of an object. 2062 2063 @param pObject : pointer to object 2064 @param lcolr : label color 2065 """ 2066 2067 _fl_set_object_lcol = cfuncproto( 2068 load_so_libforms(), "fl_set_object_lcol", \ 2069 None, [cty.POINTER(FL_OBJECT), FL_COLOR], \ 2070 """void fl_set_object_lcol(FL_OBJECT * ob, FL_COLOR lcol) 2071 """) 2072 check_admitted_listvalues(lcolr, COLOR_list) 2073 ullcolr = convert_to_FL_COLOR(lcolr) 2074 keep_elem_refs(pObject, lcolr, ullcolr) 2075 _fl_set_object_lcol(pObject, ullcolr)
2076 2077
2078 -def fl_get_object_lcol(pObject):
2079 """ 2080 fl_get_object_lcol(pObject) -> color 2081 2082 Returns the label color of an object. 2083 2084 @param pObject : pointer to object 2085 """ 2086 2087 _fl_get_object_lcol = cfuncproto( 2088 load_so_libforms(), "fl_get_object_lcol", \ 2089 FL_COLOR, [cty.POINTER(FL_OBJECT)], \ 2090 """FL_COLOR fl_set_object_lcol(FL_OBJECT * obj) 2091 """) 2092 keep_elem_refs(pObject) 2093 retval = _fl_get_object_lcol(pObject) 2094 return retval
2095 2096
2097 -def fl_set_object_return(pObject, when):
2098 """ 2099 fl_set_object_return(pObject, when) -> ID num 2100 2101 Function for setting the conditions under which an object gets 2102 returned (or its callback invoked). If the object has to do 2103 additional work on setting te condition (e.g. it has child 2104 objects that also need to be set) it has to set up it's own 2105 function that then will called in the end. This function should 2106 only be called once an object has been created completely! 2107 2108 @param pObject : pointer to object 2109 @param when : return type 2110 """ 2111 2112 _fl_set_object_return = cfuncproto( 2113 load_so_libforms(), "fl_set_object_return", \ 2114 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2115 """int fl_set_object_return(FL_OBJECT * ob, int when) DEPRECATED 2116 """) 2117 check_admitted_listvalues(when, RETURN_list) 2118 iwhen = convert_to_int(when) 2119 keep_elem_refs(pObject, when, iwhen) 2120 retval = _fl_set_object_return(pObject, iwhen) 2121 return retval
2122 2123
2124 -def fl_notify_object(pObject, cause):
2125 """ 2126 fl_notify_object(pObject, cause) 2127 2128 @param pObject : pointer to object 2129 @param cause : ? 2130 """ 2131 2132 _fl_notify_object = cfuncproto( 2133 load_so_libforms(), "fl_notify_object", \ 2134 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2135 """void fl_notify_object(FL_OBJECT * obj, int cause) 2136 """) 2137 icause = convert_to_int(cause) 2138 keep_elem_refs(pObject, cause, icause) 2139 _fl_notify_object(pObject, icause)
2140 2141
2142 -def fl_set_object_lalign(pObject, align):
2143 """ 2144 fl_set_object_lalign(pObject, align) 2145 2146 Sets alignment of an object. 2147 2148 @param pObject : pointer to object 2149 @param align : alignment of object 2150 """ 2151 2152 _fl_set_object_lalign = cfuncproto( 2153 load_so_libforms(), "fl_set_object_lalign", \ 2154 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2155 """void fl_set_object_lalign(FL_OBJECT * ob, int align) 2156 """) 2157 check_admitted_listvalues(align, ALIGN_list) 2158 ialign = convert_to_int(align) 2159 keep_elem_refs(pObject, align, ialign) 2160 _fl_set_object_lalign(pObject, ialign)
2161 2162
2163 -def fl_get_object_lalign(pObject):
2164 """ 2165 fl_get_object_lalign(pObject) -> align num. 2166 2167 Returns alignment of an object. 2168 2169 @param pObject : pointer to object 2170 """ 2171 2172 _fl_get_object_lalign = cfuncproto( 2173 load_so_libforms(), "fl_get_object_lalign", \ 2174 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 2175 """int fl_set_object_lalign(FL_OBJECT * ob) 2176 """) 2177 keep_elem_refs(pObject) 2178 retval = _fl_get_object_lalign(pObject) 2179 return retval
2180 2181
2182 -def fl_set_object_shortcut(pObject, sstr, showit):
2183 """ 2184 fl_set_object_shortcut(pObject, sstr, showit) 2185 2186 @param pObject : pointer to object 2187 @param sstr : shortcut string 2188 @param showit : flag (0|1) 2189 """ 2190 2191 _fl_set_object_shortcut = cfuncproto( 2192 load_so_libforms(), "fl_set_object_shortcut", \ 2193 None, [cty.POINTER(FL_OBJECT), STRING, cty.c_int], \ 2194 """void fl_set_object_shortcut(FL_OBJECT * obj, 2195 const char * sstr, int showit) 2196 """) 2197 ssstr = convert_to_string(sstr) 2198 ishowit = convert_to_int(showit) 2199 keep_elem_refs(pObject, sstr, ssstr, showit, ishowit) 2200 _fl_set_object_shortcut(pObject, ssstr, ishowit)
2201 2202
2203 -def fl_set_object_shortcutkey(pObject, keysym):
2204 """ 2205 fl_set_object_shortcutkey(pObject, keysym) 2206 2207 @param pObject : pointer to object 2208 @param keysym : ? 2209 """ 2210 2211 _fl_set_object_shortcutkey = cfuncproto( 2212 load_so_libforms(), "fl_set_object_shortcutkey", 2213 None, [cty.POINTER(FL_OBJECT), cty.c_uint], \ 2214 """void fl_set_object_shortcutkey(FL_OBJECT * obj, 2215 unsigned int keysym) 2216 """) 2217 uikeysym = convert_to_uint(keysym) 2218 keep_elem_refs(pObject, keysym, uikeysym) 2219 _fl_set_object_shortcutkey(pObject, uikeysym)
2220 2221
2222 -def fl_set_object_dblbuffer(pObject, y):
2223 """ 2224 fl_set_object_dblbuffer(pObject, y) 2225 2226 @param pObject : pointer to object 2227 @param y : flag (0|1) to disable/enable double buffer 2228 """ 2229 2230 _fl_set_object_dblbuffer = cfuncproto( 2231 load_so_libforms(), "fl_set_object_dblbuffer", \ 2232 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2233 """void fl_set_object_dblbuffer(FL_OBJECT * ob, int y) 2234 """) 2235 iy = convert_to_int(y) 2236 keep_elem_refs(pObject, y, iy) 2237 _fl_set_object_dblbuffer(pObject, iy)
2238 2239
2240 -def fl_set_object_color(pObject, fgcolr, bgcolr):
2241 """ 2242 fl_set_object_color(pObject, fgcolr, bgcolr) 2243 2244 Sets the color of an object. 2245 2246 @param pObject : pointer to object 2247 @param fgcolr : foreground color 2248 @param bgcolr : background color 2249 """ 2250 2251 _fl_set_object_color = cfuncproto( 2252 load_so_libforms(), "fl_set_object_color", \ 2253 None, [cty.POINTER(FL_OBJECT), FL_COLOR, FL_COLOR], \ 2254 """void fl_set_object_color(FL_OBJECT * ob, FL_COLOR col1, 2255 FL_COLOR col2) 2256 """) 2257 check_admitted_listvalues(fgcolr, COLOR_list) 2258 check_admitted_listvalues(bgcolr, COLOR_list) 2259 ulfgcolr = convert_to_FL_COLOR(fgcolr) 2260 ulbgcolr = convert_to_FL_COLOR(bgcolr) 2261 keep_elem_refs(pObject, fgcolr, ulfgcolr, bgcolr, ulbgcolr) 2262 _fl_set_object_color(pObject, ulfgcolr, ulbgcolr)
2263 2264 2265 #def fl_set_object_color(pObject, fgcolr, bgcolr) *API change*
2266 -def fl_get_object_color(pObject):
2267 """ 2268 fl_set_object_color(pObject) -> fgcolr, bgcolr 2269 2270 Returns the foreground and background colors of an object. 2271 2272 @param pObject : pointer to object 2273 """ 2274 2275 _fl_get_object_color = cfuncproto( 2276 load_so_libforms(), "fl_get_object_color", \ 2277 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_COLOR), \ 2278 cty.POINTER(FL_COLOR)], \ 2279 """void fl_get_object_color(FL_OBJECT * ob, FL_COLOR * col1, 2280 FL_COLOR * col2) 2281 """) 2282 fgcolr, pfgcolr = make_FL_COLOR_and_pointer() 2283 bgcolr, pbgcolr = make_FL_COLOR_and_pointer() 2284 keep_elem_refs(pObject, fgcolr, pfgcolr, bgcolr, pbgcolr) 2285 _fl_get_object_color(pObject, pfgcolr, pbgcolr) 2286 return fgcolr, bgcolr
2287 2288
2289 -def fl_set_object_label(pObject, label):
2290 """ 2291 fl_set_object_label(pObject, label) 2292 2293 Sets the label of an object. 2294 2295 @param pObject : pointer to object 2296 @param label : label of object 2297 """ 2298 2299 _fl_set_object_label = cfuncproto( 2300 load_so_libforms(), "fl_set_object_label", \ 2301 None, [cty.POINTER(FL_OBJECT), STRING], \ 2302 """void fl_set_object_label(FL_OBJECT * ob, const char * label) 2303 """) 2304 slabel = convert_to_string(label) 2305 keep_elem_refs(pObject, label, slabel) 2306 _fl_set_object_label(pObject, slabel)
2307 2308
2309 -def fl_get_object_label(pObject):
2310 """ 2311 fl_get_object_label(pObject) -> label 2312 2313 Returns the label of an object. 2314 2315 @param pObject : pointer to object 2316 """ 2317 2318 _fl_get_object_label = cfuncproto( 2319 load_so_libforms(), "fl_get_object_label", \ 2320 STRING, [cty.POINTER(FL_OBJECT)], \ 2321 """const char * fl_set_object_label(FL_OBJECT * obj) 2322 """) 2323 keep_elem_refs(pObject) 2324 retval = _fl_get_object_label(pObject) 2325 return retval
2326 2327
2328 -def fl_set_object_helper(pObject, tip):
2329 """ 2330 fl_set_object_helper(pObject, tip) 2331 2332 Sets the tooltip of an object. 2333 2334 @param pObject : pointer to object 2335 @param tip : tooltip text for object 2336 """ 2337 2338 _fl_set_object_helper = cfuncproto( 2339 load_so_libforms(), "fl_set_object_helper", \ 2340 None, [cty.POINTER(FL_OBJECT), STRING], \ 2341 """void fl_set_object_helper(FL_OBJECT * ob, const char * tip) 2342 """) 2343 stip = convert_to_string(tip) 2344 keep_elem_refs(pObject, tip, stip) 2345 _fl_set_object_helper(pObject, stip)
2346 2347
2348 -def fl_set_object_position(pObject, x, y):
2349 """ 2350 fl_set_object_position(pObject, x, y) 2351 2352 Sets position of an object. 2353 2354 @param pObject : pointer of object 2355 @param x : horizontal position 2356 @param y : vertical position 2357 """ 2358 2359 _fl_set_object_position = cfuncproto( 2360 load_so_libforms(), "fl_set_object_position", \ 2361 None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 2362 """void fl_set_object_position(FL_OBJECT * obj, FL_Coord x, 2363 FL_Coord y) 2364 """) 2365 ix = convert_to_FL_Coord(x) 2366 iy = convert_to_FL_Coord(y) 2367 keep_elem_refs(pObject, x, ix, y, iy) 2368 _fl_set_object_position(pObject, ix, iy)
2369 2370 2371 #def fl_get_object_size(pObject, w, h) *API change*
2372 -def fl_get_object_size(pObject):
2373 """ 2374 fl_get_object_size(pObject) -> width, height 2375 2376 Returns the size of an object. 2377 2378 @param pObject : pointer to object 2379 """ 2380 2381 _fl_get_object_size = cfuncproto( 2382 load_so_libforms(), "fl_get_object_size", \ 2383 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 2384 cty.POINTER(FL_Coord)], \ 2385 """void fl_get_object_size(FL_OBJECT * obj, FL_Coord * w, 2386 FL_Coord * h) 2387 """) 2388 w, pw = make_FL_Coord_and_pointer() 2389 h, ph = make_FL_Coord_and_pointer() 2390 keep_elem_refs(pObject, w, h, pw, ph) 2391 _fl_get_object_size(pObject, pw, ph) 2392 return w, h
2393 2394
2395 -def fl_set_object_size(pObject, w, h):
2396 """ 2397 fl_set_object_size(pObject, w, h) 2398 2399 Sets the size of an object. 2400 2401 @param pObject : pointer to object 2402 @param w : width of object 2403 @param h : height of object 2404 """ 2405 2406 _fl_set_object_size = cfuncproto( 2407 load_so_libforms(), "fl_set_object_size", \ 2408 None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 2409 """void fl_set_object_size(FL_OBJECT * obj, FL_Coord w, 2410 FL_Coord h) 2411 """) 2412 iw = convert_to_FL_Coord(w) 2413 ih = convert_to_FL_Coord(h) 2414 keep_elem_refs(pObject, w, iw, h, ih) 2415 _fl_set_object_size(pObject, iw, ih)
2416 2417
2418 -def fl_set_object_automatic(pObject, flag):
2419 """ 2420 fl_set_object_automatic(pObject, flag) 2421 2422 @param pObject : pointer to object 2423 @param flag : flag (0|1) 2424 """ 2425 2426 _fl_set_object_automatic = cfuncproto( 2427 load_so_libforms(), "fl_set_object_automatic", 2428 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2429 """void fl_set_object_automatic(FL_OBJECT * ob, int flag) 2430 """) 2431 iflag = convert_to_int(flag) 2432 keep_elem_refs(pObject, flag, iflag) 2433 _fl_set_object_automatic(pObject, iflag)
2434 2435
2436 -def fl_object_is_automatic(pObject):
2437 """ 2438 fl_object_is_automatic(pObject) -> flag num. 2439 2440 @param pObject : pointer to object 2441 """ 2442 2443 _fl_object_is_automatic = cfuncproto( 2444 load_so_libforms(), "fl_object_is_automatic", 2445 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 2446 """int fl_object_is_automatic(FL_OBJECT * obj) 2447 """) 2448 keep_elem_refs(pObject) 2449 retval = _fl_object_is_automatic(pObject) 2450 return retval
2451 2452
2453 -def fl_draw_object_label(pObject):
2454 """ 2455 fl_draw_object_label(pObject) 2456 2457 @param pObject : pointer to object 2458 """ 2459 2460 _fl_draw_object_label = cfuncproto( 2461 load_so_libforms(), "fl_draw_object_label", \ 2462 None, [cty.POINTER(FL_OBJECT)], \ 2463 """void fl_draw_object_label(FL_OBJECT * ob) 2464 """) 2465 keep_elem_refs(pObject) 2466 _fl_draw_object_label(pObject)
2467 2468
2469 -def fl_draw_object_label_outside(pObject):
2470 """ 2471 fl_draw_object_label_outside(pObject) 2472 2473 @param pObject : pointer to object 2474 """ 2475 2476 _fl_draw_object_label_outside = cfuncproto( 2477 load_so_libforms(), "fl_draw_object_label_outside", 2478 None, [cty.POINTER(FL_OBJECT)], \ 2479 """void fl_draw_object_label_outside(FL_OBJECT * ob) 2480 """) 2481 keep_elem_refs(pObject) 2482 _fl_draw_object_label_outside(pObject)
2483 2484
2485 -def fl_get_object_component(pObjectComposite, objclass, compontype, numb):
2486 """ fl_get_object_component(pObjectComposite, objclass, compontype, numb) -> pObject 2487 """ 2488 2489 _fl_get_object_component = cfuncproto( 2490 load_so_libforms(), "fl_get_object_component", 2491 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT), cty.c_int, 2492 cty.c_int, cty.c_int], \ 2493 """FL_OBJECT * fl_get_object_component(FL_OBJECT * composite, 2494 int objclass, int type, int numb) 2495 """) 2496 iobjclass = convert_to_int(objclass) 2497 icompontype = convert_to_int(compontype) 2498 inumb = convert_to_int(numb) 2499 keep_elem_refs(pObjectComposite, objclass, iobjclass, compontype, \ 2500 icompontype, numb, inumb) 2501 retval = _fl_get_object_component(pObjectComposite, iobjclass, \ 2502 icompontype, inumb) 2503 return retval
2504 2505 2506 # cfunction for _fl_for_all_objects 2507 cfunc_int_pobject_pvoid = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), \ 2508 cty.c_void_p) 2509
2510 -def fl_for_all_objects(pForm, py_cb, v):
2511 """ 2512 fl_for_all_objects(pForm, py_cb, v) 2513 2514 @param pForm : pointer to form 2515 @param py_cb : python function, fn(pObject, ptr_void) -> num. 2516 @param v : argument 2517 """ 2518 2519 _fl_for_all_objects = cfuncproto( 2520 load_so_libforms(), "fl_for_all_objects", \ 2521 None, [cty.POINTER(FL_FORM), cfunc_int_pobject_pvoid, \ 2522 cty.c_void_p], \ 2523 """void fl_for_all_objects(FL_FORM * form, int ( * cb ) \ 2524 ( FL_OBJECT *, void * ), void * v) 2525 """) 2526 c_cb = cfunc_int_pobject_pvoid(py_cb) 2527 pv = cty.cast(v, cty.c_void_p) 2528 keep_cfunc_refs(c_cb, py_cb) 2529 keep_elem_refs(pForm, v, pv) 2530 _fl_for_all_objects(pForm, c_cb, pv)
2531 2532 2533 fl_draw_object_outside_label = fl_draw_object_label_outside 2534 2535
2536 -def fl_set_object_dblclick(pObject, timeout):
2537 """ 2538 fl_set_object_dblclick(pObject, timeout) 2539 2540 Sets double click timeout value of an object. 2541 2542 @param pObject : pointer to object 2543 @param timeout : timeout value for double click 2544 """ 2545 2546 _fl_set_object_dblclick = cfuncproto( 2547 load_so_libforms(), "fl_set_object_dblclick", \ 2548 None, [cty.POINTER(FL_OBJECT), cty.c_ulong], \ 2549 """void fl_set_object_dblclick(FL_OBJECT *obj, unsigned \ 2550 long timeout) 2551 """) 2552 ultimeout = convert_to_ulong(timeout) 2553 keep_elem_refs(pObject, timeout, ultimeout) 2554 _fl_set_object_dblclick(pObject, ultimeout)
2555 2556
2557 -def fl_get_object_dblclick(pObject):
2558 """ 2559 fl_get_object_dblclick(pObject) -> timeout value 2560 2561 Return double click timeout value of an object. 2562 2563 @param pObject : pointer to object 2564 """ 2565 2566 _fl_get_object_dblclick = cfuncproto( 2567 load_so_libforms(), "fl_get_object_dblclick", \ 2568 cty.c_ulong, [cty.POINTER(FL_OBJECT)], \ 2569 """unsigned long fl_get_object_dblclick(FL_OBJECT *obj) 2570 """) 2571 keep_elem_refs(pObject) 2572 retval = _fl_get_object_dblclick(pObject) 2573 return retval
2574 2575
2576 -def fl_set_object_geometry(pObject, x, y, w, h):
2577 """ 2578 fl_set_object_geometry(pObject, x, y, w, h) 2579 2580 Sets the geometry (position and size) of an object. 2581 2582 @param pObject : pointer to object 2583 @param x : horizontal position (upper-left corner) 2584 @param y : vertical position (upper-left corner) 2585 @param w : width of the object in pixels 2586 @param h : height of the object in pixels 2587 """ 2588 2589 _fl_set_object_geometry = cfuncproto( 2590 load_so_libforms(), "fl_set_object_geometry", \ 2591 None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord, FL_Coord, 2592 FL_Coord], \ 2593 """void fl_set_object_geometry(FL_OBJECT * obj, FL_Coord x, 2594 FL_Coord y, FL_Coord w, FL_Coord h) 2595 """) 2596 ix = convert_to_FL_Coord(x) 2597 iy = convert_to_FL_Coord(y) 2598 iw = convert_to_FL_Coord(w) 2599 ih = convert_to_FL_Coord(h) 2600 keep_elem_refs(pObject, x, ix, y, iy, w, iw, h, ih) 2601 _fl_set_object_geometry(pObject, ix, iy, iw, ih)
2602 2603
2604 -def fl_move_object(pObject, dx, dy):
2605 """ 2606 fl_move_object(pObject, dx, dy) 2607 2608 @param pObject : pointer to object 2609 """ 2610 2611 _fl_move_object = cfuncproto( 2612 load_so_libforms(), "fl_move_object", \ 2613 None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 2614 """void fl_move_object(FL_OBJECT * obj, FL_Coord dx, FL_Coord dy) 2615 """) 2616 idx = convert_to_int(dx) 2617 idy = convert_to_int(dy) 2618 keep_elem_refs(pObject, dx, idx, dy, idy) 2619 _fl_move_object(pObject, idx, idy)
2620 2621 2622 fl_set_object_lcolor = fl_set_object_lcol 2623 2624
2625 -def fl_fit_object_label(pObject, xmargin, ymargin):
2626 """ 2627 fl_fit_object_label(pObject, xmargin, ymargin) 2628 2629 Checks if the label of an object fits into it (after x- and 2630 y-margin have been added). If not, all objects and the form 2631 are enlarged by the necessary factor (but never by more than 2632 a factor of 1.5) 2633 2634 @param pObject : pointer to object 2635 @param xmargin : horizontal margin 2636 @param ymargin : vertical margin 2637 """ 2638 2639 _fl_fit_object_label = cfuncproto( 2640 load_so_libforms(), "fl_fit_object_label",\ 2641 None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord],\ 2642 """void fl_fit_object_label(FL_OBJECT * obj, FL_Coord xmargin, 2643 FL_Coord ymargin) 2644 """) 2645 ixmargin = convert_to_int(xmargin) 2646 iymargin = convert_to_int(ymargin) 2647 keep_elem_refs(pObject, xmargin, ixmargin, ymargin, iymargin) 2648 _fl_fit_object_label(pObject, ixmargin, iymargin)
2649 2650 2651 #def fl_get_object_geometry(pObject, x, y, w, h) *API change*
2652 -def fl_get_object_geometry(pObject):
2653 """ 2654 fl_get_object_geometry(pObject) -> hor-xpos, vert-ypos, width, height 2655 2656 Returns the geometry (position and size) of an object. 2657 2658 @param pObject : pointer to object 2659 """ 2660 2661 _fl_get_object_geometry = cfuncproto( 2662 load_so_libforms(), "fl_get_object_geometry",\ 2663 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord),\ 2664 cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 2665 """void fl_get_object_geometry(FL_OBJECT * ob, FL_Coord * x, 2666 FL_Coord * y, FL_Coord * w, FL_Coord * h) 2667 """) 2668 x, px = make_FL_Coord_and_pointer() 2669 y, py = make_FL_Coord_and_pointer() 2670 w, pw = make_FL_Coord_and_pointer() 2671 h, ph = make_FL_Coord_and_pointer() 2672 keep_elem_refs(pObject, x, px, y, py, w, pw, h, ph) 2673 _fl_get_object_geometry(pObject, px, py, pw, ph) 2674 return x, y, w,h
2675 2676 2677 #def fl_get_object_position(pObject, x, y) *API change*
2678 -def fl_get_object_position(pObject):
2679 """ 2680 fl_get_object_position(pObject) -> xpos, ypos 2681 2682 Returns the position of an object. 2683 2684 @param pObject : pointer to object 2685 """ 2686 2687 _fl_get_object_position = cfuncproto( 2688 load_so_libforms(), "fl_get_object_position",\ 2689 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 2690 cty.POINTER(FL_Coord)],\ 2691 """void fl_get_object_position(FL_OBJECT * ob, FL_Coord * x, 2692 FL_Coord * y) 2693 """) 2694 x, px = make_FL_Coord_and_pointer() 2695 y, py = make_FL_Coord_and_pointer() 2696 keep_elem_refs(pObject, x, px, y, py) 2697 _fl_get_object_position(pObject, px, py) 2698 return x,y
2699 2700 2701 # this one takes into account the label 2702 2703 #def fl_get_object_bbox(pObject, x, y, w, h) *API change*
2704 -def fl_get_object_bbox(pObject):
2705 """ 2706 fl_get_object_bbox(pObject) -> x, y, w, h 2707 2708 @param pObject : pointer to object 2709 """ 2710 2711 _fl_get_object_bbox = cfuncproto( 2712 load_so_libforms(), "fl_get_object_bbox",\ 2713 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord),\ 2714 cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 2715 cty.POINTER(FL_Coord)],\ 2716 """void fl_get_object_bbox(FL_OBJECT * obj, FL_Coord * x, 2717 FL_Coord * y, FL_Coord * w, FL_Coord * h) 2718 """) 2719 x, px = make_FL_Coord_and_pointer() 2720 y, py = make_FL_Coord_and_pointer() 2721 w, pw = make_FL_Coord_and_pointer() 2722 h, ph = make_FL_Coord_and_pointer() 2723 keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 2724 _fl_get_object_bbox(pObject, px, py, pw, ph) 2725 return x, y, w,h
2726 2727 2728 fl_compute_object_geometry = fl_get_object_bbox 2729 2730
2731 -def fl_call_object_callback(pObject):
2732 """ 2733 fl_call_object_callback(pObject) 2734 2735 @param pObject : pointer to object 2736 """ 2737 2738 _fl_call_object_callback = cfuncproto( 2739 load_so_libforms(), "fl_call_object_callback",\ 2740 None, [cty.POINTER(FL_OBJECT)],\ 2741 """void fl_call_object_callback(FL_OBJECT * ob) 2742 """) 2743 keep_elem_refs(pObject) 2744 _fl_call_object_callback(pObject)
2745 2746 2747 #already defined in xfdata 2748 #FL_HANDLEPTR = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), cty.c_int, \ 2749 # FL_Coord, FL_Coord, cty.c_int, cty.c_void_p) 2750
2751 -def fl_set_object_prehandler(pObject, py_HandlerPtr):
2752 """ 2753 fl_set_object_prehandler(pObject, py_HandlerPtr) -> pHandlerPtr 2754 2755 @param pObject : pointer to object 2756 @param py_HandlerPtr : python callback function, fn(pObject, 2757 num, coord, coord, num, ptr_void) -> num 2758 """ 2759 2760 _fl_set_object_prehandler = cfuncproto( 2761 load_so_libforms(), "fl_set_object_prehandler", 2762 FL_HANDLEPTR, [cty.POINTER(FL_OBJECT), FL_HANDLEPTR],\ 2763 """FL_HANDLEPTR fl_set_object_prehandler(FL_OBJECT * ob, 2764 FL_HANDLEPTR phandler) 2765 """) 2766 c_HandlerPtr = FL_HANDLEPTR(py_HandlerPtr) 2767 keep_cfunc_refs(c_HandlerPtr, py_HandlerPtr) 2768 keep_elem_refs(pObject) 2769 retval = _fl_set_object_prehandler(pObject, c_HandlerPtr) 2770 return retval
2771 2772
2773 -def fl_set_object_posthandler(pObject, py_HandlerPtr):
2774 """ 2775 fl_set_object_posthandler(pObject, py_HandlerPtr) -> pHandlerPtr 2776 2777 @param pObject : pointer to object 2778 @param py_HandlerPtr : python callback function, fn(pObject, 2779 num, coord, coord, num, ptr_void) -> num 2780 """ 2781 2782 _fl_set_object_posthandler = cfuncproto( 2783 load_so_libforms(), "fl_set_object_posthandler", 2784 FL_HANDLEPTR, [cty.POINTER(FL_OBJECT), FL_HANDLEPTR],\ 2785 """FL_HANDLEPTR fl_set_object_posthandler(FL_OBJECT * ob, 2786 FL_HANDLEPTR post) 2787 """) 2788 c_HandlerPtr = FL_HANDLEPTR(py_HandlerPtr) 2789 keep_cfunc_refs(c_HandlerPtr, py_HandlerPtr) 2790 keep_elem_refs(pObject) 2791 retval = _fl_set_object_posthandler(pObject, c_HandlerPtr) 2792 return retval
2793 2794 2795 #already defined in xfdata 2796 #FL_CALLBACKPTR = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_long) 2797
2798 -def fl_set_object_callback(pObject, py_CallbackPtr, argum):
2799 """ 2800 fl_set_object_callback(pObject, py_CallbackPtr, argum) -> c_callback func. 2801 2802 Calls a callback function bound to an object, if a condition is met. 2803 2804 @param pObject : pointer to object 2805 @param py_CallbackPtr : a python function with no () and no args to 2806 be used as callback, fn(pObject, longnum) 2807 @param argum : argument being passed to function 2808 """ 2809 2810 _fl_set_object_callback = cfuncproto( 2811 load_so_libforms(), "fl_set_object_callback",\ 2812 FL_CALLBACKPTR, [cty.POINTER(FL_OBJECT), FL_CALLBACKPTR, 2813 cty.c_long], 2814 """FL_CALLBACKPTR fl_set_object_callback(FL_OBJECT * obj,\ 2815 FL_CALLBACKPTR callback, long int argument) 2816 """) 2817 largum = convert_to_long(argum) 2818 c_CallbackPtr = FL_CALLBACKPTR(py_CallbackPtr) 2819 keep_cfunc_refs(c_CallbackPtr, py_CallbackPtr) 2820 keep_elem_refs(pObject, argum, largum) 2821 retval = _fl_set_object_callback(pObject, c_CallbackPtr, largum) 2822 return retval
2823 2824 2825 fl_set_object_align = fl_set_object_lalign 2826 fl_set_call_back = fl_set_object_callback 2827 2828
2829 -def fl_redraw_object(pObject):
2830 """ 2831 fl_redraw_object(pObject) 2832 2833 @param pObject : pointer to object 2834 """ 2835 2836 _fl_redraw_object = cfuncproto( 2837 load_so_libforms(), "fl_redraw_object",\ 2838 None, [cty.POINTER(FL_OBJECT)],\ 2839 """void fl_redraw_object(FL_OBJECT * obj) 2840 """) 2841 keep_elem_refs(pObject) 2842 _fl_redraw_object(pObject)
2843 2844
2845 -def fl_scale_object(pObject, xs, ys):
2846 """ 2847 fl_scale_object(pObject, xs, ys) 2848 2849 Scales (shrink or enlarge) an object. 2850 2851 @param pObject : pointer to object 2852 @param xs : new horizontal factor 2853 @param ys : new vertical factor 2854 """ 2855 2856 _fl_scale_object = cfuncproto( 2857 load_so_libforms(), "fl_scale_object",\ 2858 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double],\ 2859 """void fl_scale_object(FL_OBJECT * ob, double xs, double ys) 2860 """) 2861 fxs = convert_to_double(xs) 2862 fys = convert_to_double(ys) 2863 keep_elem_refs(pObject, xs, fxs, ys, fys) 2864 _fl_scale_object(pObject, fxs, fys)
2865 2866
2867 -def fl_show_object(pObject):
2868 """ 2869 fl_show_object(pObject) 2870 2871 @param pObject : pointer to object 2872 """ 2873 2874 _fl_show_object = cfuncproto( 2875 load_so_libforms(), "fl_show_object",\ 2876 None, [cty.POINTER(FL_OBJECT)],\ 2877 """void fl_show_object(FL_OBJECT * ob) 2878 """) 2879 keep_elem_refs(pObject) 2880 _fl_show_object(pObject)
2881 2882
2883 -def fl_hide_object(pObject):
2884 """ 2885 fl_hide_object(pObject) 2886 2887 @param pObject : pointer to object 2888 """ 2889 2890 _fl_hide_object = cfuncproto( 2891 load_so_libforms(), "fl_hide_object",\ 2892 None, [cty.POINTER(FL_OBJECT)],\ 2893 """void fl_hide_object(FL_OBJECT * ob) 2894 """) 2895 keep_elem_refs(pObject) 2896 _fl_hide_object(pObject)
2897 2898
2899 -def fl_object_is_visible(pObject):
2900 """ 2901 fl_object_is_visible(pObject) -> num. 2902 2903 @param pObject : pointer to object 2904 """ 2905 2906 _fl_object_is_visible = cfuncproto( 2907 load_so_libforms(), "fl_object_is_visible",\ 2908 cty.c_int, [cty.POINTER(FL_OBJECT)],\ 2909 """int fl_object_is_visible(FL_OBJECT * obj) 2910 """) 2911 keep_elem_refs(pObject) 2912 retval = _fl_object_is_visible(pObject) 2913 return retval
2914 2915
2916 -def fl_free_object(pObject):
2917 """ 2918 fl_free_object(pObject) 2919 2920 @param pObject : pointer to object 2921 """ 2922 2923 _fl_free_object = cfuncproto( 2924 load_so_libforms(), "fl_free_object",\ 2925 None, [cty.POINTER(FL_OBJECT)],\ 2926 """void fl_free_object(FL_OBJECT * obj) 2927 """) 2928 keep_elem_refs(pObject) 2929 _fl_free_object(pObject)
2930 2931
2932 -def fl_delete_object(pObject):
2933 """ 2934 fl_delete_object(pObject) 2935 2936 @param pObject : pointer to object 2937 """ 2938 2939 _fl_delete_object = cfuncproto( 2940 load_so_libforms(), "fl_delete_object",\ 2941 None, [cty.POINTER(FL_OBJECT)],\ 2942 """void fl_delete_object(FL_OBJECT * obj) 2943 """) 2944 keep_elem_refs(pObject) 2945 _fl_delete_object(pObject)
2946 2947
2948 -def fl_get_object_return_state(pObject):
2949 """ 2950 fl_get_object_return_state(pObject) -> ID num 2951 2952 @param pObject : pointer to object 2953 """ 2954 2955 _fl_get_object_return_state = cfuncproto( 2956 load_so_libforms(), "fl_get_object_return_state", 2957 cty.c_int, [cty.POINTER(FL_OBJECT)],\ 2958 """int fl_get_object_return_state(FL_OBJECT * obj) 2959 """) 2960 keep_elem_refs(pObject) 2961 retval = _fl_get_object_return_state(pObject) 2962 return retval
2963 2964
2965 -def fl_trigger_object(pObject):
2966 """ 2967 fl_trigger_object(pObject) 2968 2969 @param pObject : pointer to object 2970 """ 2971 2972 _fl_trigger_object = cfuncproto( 2973 load_so_libforms(), "fl_trigger_object",\ 2974 None, [cty.POINTER(FL_OBJECT)],\ 2975 """void fl_trigger_object(FL_OBJECT * obj) 2976 """) 2977 keep_elem_refs(pObject) 2978 _fl_trigger_object(pObject)
2979 2980
2981 -def fl_activate_object(pObject):
2982 """ 2983 fl_activate_object(pObject) 2984 2985 @param pObject : pointer to object 2986 """ 2987 2988 _fl_activate_object = cfuncproto( 2989 load_so_libforms(), "fl_activate_object",\ 2990 None, [cty.POINTER(FL_OBJECT)],\ 2991 """void fl_activate_object(FL_OBJECT * ob) 2992 """) 2993 keep_elem_refs(pObject) 2994 _fl_activate_object(pObject)
2995 2996
2997 -def fl_deactivate_object(pObject):
2998 """ 2999 fl_deactivate_object(pObject) 3000 3001 @param pObject : pointer to object 3002 """ 3003 3004 _fl_deactivate_object = cfuncproto( 3005 load_so_libforms(), "fl_deactivate_object",\ 3006 None, [cty.POINTER(FL_OBJECT)],\ 3007 """void fl_deactivate_object(FL_OBJECT * ob) 3008 """) 3009 keep_elem_refs(pObject) 3010 _fl_deactivate_object(pObject)
3011 3012
3013 -def fl_object_is_active(pObject):
3014 """ 3015 fl_object_is_active(pObject) -> num. 3016 3017 Returns if object is active and reacts to event. 3018 3019 @param pObject : pointer to object 3020 """ 3021 3022 _fl_object_is_active = cfuncproto( 3023 load_so_libforms(), "fl_object_is_active",\ 3024 cty.c_int, [cty.POINTER(FL_OBJECT)],\ 3025 """int fl_object_is_active(FL_OBJECT * ob) 3026 """) 3027 keep_elem_refs(pObject) 3028 retval = _fl_object_is_active(pObject) 3029 return retval
3030 3031 3032 # cfunction for _fl_enumerate_fonts 3033 cfunc_none_string = cty.CFUNCTYPE(None, STRING) 3034
3035 -def fl_enumerate_fonts(py_output, shortform):
3036 """ fl_enumerate_fonts(py_output, shortform) -> ID num 3037 """ 3038 3039 _fl_enumerate_fonts = cfuncproto( 3040 load_so_libforms(), "fl_enumerate_fonts",\ 3041 cty.c_int, [cfunc_none_string, cty.c_int],\ 3042 """int fl_enumerate_fonts(void ( * output )( const char *s ), \ 3043 int shortform) 3044 """) 3045 ishortform = convert_to_int(shortform) 3046 c_output = cfunc_none_string(py_output) 3047 keep_cfunc_refs(c_output, py_output) 3048 keep_elem_refs(shortform, ishortform) 3049 retval = _fl_enumerate_fonts(c_output, ishortform) 3050 return retval
3051 3052
3053 -def fl_set_font_name(n, name):
3054 """ fl_set_font_name(n, name) -> ID num 3055 """ 3056 3057 _fl_set_font_name = cfuncproto( 3058 load_so_libforms(), "fl_set_font_name",\ 3059 cty.c_int, [cty.c_int, STRING],\ 3060 """int fl_set_font_name(int n, const char * name) 3061 """) 3062 inum = convert_to_int(n) 3063 sname = convert_to_string(name) 3064 keep_elem_refs(n, inum, name, sname) 3065 retval = _fl_set_font_name(inum, sname) 3066 return retval
3067 3068
3069 -def fl_set_font(numb, size):
3070 """ fl_set_font(numb, size) 3071 """ 3072 3073 _fl_set_font = cfuncproto( 3074 load_so_libforms(), "fl_set_font",\ 3075 None, [cty.c_int, cty.c_int],\ 3076 """void fl_set_font(int numb, int size) 3077 """) 3078 inumb = convert_to_int(numb) 3079 isize = convert_to_int(size) 3080 keep_elem_refs(numb, inumb, size, isize) 3081 _fl_set_font(inumb, isize)
3082 3083 3084 # routines that facilitate free object 3085 3086 #def fl_get_char_height(style, size, asc, desc) *API change*
3087 -def fl_get_char_height(style, size):
3088 """ fl_get_char_height(style, size) -> height num., asc, desc 3089 """ 3090 3091 _fl_get_char_height = cfuncproto( 3092 load_so_libforms(), "fl_get_char_height",\ 3093 cty.c_int, [cty.c_int, cty.c_int, cty.POINTER(cty.c_int), 3094 cty.POINTER(cty.c_int)],\ 3095 """int fl_get_char_height(int style, int size, int * asc, 3096 int * desc) 3097 """) 3098 istyle = convert_to_int(style) 3099 isize = convert_to_int(size) 3100 asc, pasc = make_int_and_pointer() # not sure 3101 desc, pdesc = make_int_and_pointer() 3102 keep_elem_refs(style, istyle, size, isize, asc, desc, pasc, pdesc) 3103 retval = _fl_get_char_height(istyle, isize, pasc, pdesc) 3104 return retval, asc, desc
3105 3106
3107 -def fl_get_char_width(style, size):
3108 """ fl_get_char_width(style, size) -> width num. 3109 """ 3110 3111 _fl_get_char_width = cfuncproto( 3112 load_so_libforms(), "fl_get_char_width",\ 3113 cty.c_int, [cty.c_int, cty.c_int],\ 3114 """int fl_get_char_width(int style, int size) 3115 """) 3116 istyle = convert_to_int(style) 3117 isize = convert_to_int(size) 3118 keep_elem_refs(style, istyle, size, isize) 3119 retval = _fl_get_char_width(istyle, isize) 3120 return retval
3121 3122 3123 #def fl_get_string_height(style, size, strng, strglen, asc, desc) *API change*
3124 -def fl_get_string_height(style, size, strng, strglen):
3125 """ fl_get_string_height(style, size, strng, strglen) -> height num., asc, desc 3126 """ 3127 3128 _fl_get_string_height = cfuncproto( 3129 load_so_libforms(), "fl_get_string_height",\ 3130 cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int, 3131 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 3132 """int fl_get_string_height(int style, int size, const char * s, 3133 int len, int * asc, int * desc) 3134 """) 3135 istyle = convert_to_int(style) 3136 isize = convert_to_int(size) 3137 sstrng = convert_to_string(strng) 3138 istrglen = convert_to_int(strglen) 3139 #pasc = cty.cast(asc, cty.POINTER(cty.c_int)) 3140 asc, pasc = make_int_and_pointer() 3141 #pdesc = cty.cast(desc, cty.POINTER(cty.c_int)) 3142 desc, pdesc = make_int_and_pointer() 3143 keep_elem_refs(style, istyle, size, isize, strng, sstrng, strglen,\ 3144 istrglen, asc, desc, pasc, pdesc) 3145 retval = _fl_get_string_height(istyle, isize, sstrng, istrglen,\ 3146 pasc, pdesc) 3147 return retval, asc, desc
3148 3149
3150 -def fl_get_string_width(style, size, s, strglen):
3151 """ fl_get_string_width(style, size, s, strglen) -> width num. 3152 """ 3153 3154 _fl_get_string_width = cfuncproto( 3155 load_so_libforms(), "fl_get_string_width",\ 3156 cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int],\ 3157 """int fl_get_string_width(int style, int size, const char * s, 3158 int len) 3159 """) 3160 istyle = convert_to_int(style) 3161 isize = convert_to_int(size) 3162 ss = convert_to_string(s) 3163 istrglen = convert_to_int(strglen) 3164 keep_elem_refs(style, istyle, size, isize, s, ss, strglen, istrglen) 3165 retval = _fl_get_string_width(istyle, isize, ss, istrglen) 3166 return retval
3167 3168
3169 -def fl_get_string_widthTAB(style, size, s, strglen):
3170 """ fl_get_string_widthTAB(style, size, s, strglen) -> width num. 3171 """ 3172 3173 _fl_get_string_widthTAB = cfuncproto( 3174 load_so_libforms(), "fl_get_string_widthTAB",\ 3175 cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int],\ 3176 """int fl_get_string_widthTAB(int style, int size, const char * s, 3177 int len) 3178 """) 3179 istyle = convert_to_int(style) 3180 isize = convert_to_int(size) 3181 ss = convert_to_string(s) 3182 istrglen = convert_to_int(strglen) 3183 keep_elem_refs(style, istyle, size, isize, s, ss, strglen, istrglen) 3184 retval = _fl_get_string_widthTAB(istyle, isize, ss, istrglen) 3185 return retval
3186 3187 3188 #def fl_get_string_dimension(fntstyle, fntsize, s, strglen, width, height) *API change*
3189 -def fl_get_string_dimension(fntstyle, fntsize, s, strglen):
3190 """ fl_get_string_dimension(fntstyle, fntsize, s, strglen) -> width, height 3191 """ 3192 3193 _fl_get_string_dimension = cfuncproto( 3194 load_so_libforms(), "fl_get_string_dimension",\ 3195 None, [cty.c_int, cty.c_int, STRING, cty.c_int, 3196 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 3197 """void fl_get_string_dimension(int fntstyle, int fntsize, 3198 const char * s, int len, int * width, int * height) 3199 """) 3200 ifntstyle = convert_to_int(fntstyle) 3201 ifntsize = convert_to_int(fntsize) 3202 ss = convert_to_string(s) 3203 istrglen = convert_to_int(strglen) 3204 width, pwidth = make_int_and_pointer() 3205 height, pheight = make_int_and_pointer() 3206 keep_elem_refs(fntstyle, ifntstyle, fntsize, ifntsize, s, ss, strglen, 3207 istrglen, width, height, pwidth, pheight) 3208 _fl_get_string_dimension(ifntstyle, ifntsize, ss, istrglen, pwidth, 3209 pheight) 3210 return width, height
3211 3212 3213 fl_get_string_size = fl_get_string_dimension 3214 3215 3216 #def fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff, xx, yy) *API change*
3217 -def fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff):
3218 """ fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff) -> xx, yy 3219 """ 3220 3221 _fl_get_align_xy = cfuncproto( 3222 load_so_libforms(), "fl_get_align_xy",\ 3223 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int,\ 3224 cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.POINTER(cty.c_int),\ 3225 cty.POINTER(cty.c_int)],\ 3226 """void fl_get_align_xy(int align, int x, int y, int w, int h, 3227 int xsize, int ysize, int xoff, int yoff, int * xx, int * yy) 3228 """) 3229 check_admitted_listvalues(align, ALIGN_list) 3230 ialign = convert_to_int(align) 3231 ix = convert_to_int(x) 3232 iy = convert_to_int(y) 3233 iw = convert_to_int(w) 3234 ih = convert_to_int(h) 3235 ixsize = convert_to_int(xsize) 3236 iysize = convert_to_int(ysize) 3237 ixoff = convert_to_int(xoff) 3238 iyoff = convert_to_int(yoff) 3239 xx, pxx = make_int_and_pointer() 3240 yy, pyy = make_int_and_pointer() 3241 keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, xsize, ixsize, 3242 ysize, iysize, xoff, ixoff, yoff, iyoff, xx, yy, pxx, pyy) 3243 _fl_get_align_xy(ialign, ix, iy, iw, ih, ixsize, iysize, ixoff, 3244 iyoff, pxx, pyy) 3245 return xx, yy
3246 3247
3248 -def fl_drw_text(align, x, y, w, h, colr, style, size, txtstr):
3249 """ fl_drw_text(align, x, y, w, h, colr, style, size, txtstr) 3250 """ 3251 3252 _fl_drw_text = cfuncproto( 3253 load_so_libforms(), "fl_drw_text",\ 3254 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 3255 cty.c_int, cty.c_int, STRING],\ 3256 """void fl_drw_text(int align, FL_Coord x, FL_Coord y, FL_Coord w, 3257 FL_Coord h, FL_COLOR c, int style, int size, const char * istr) 3258 """) 3259 check_admitted_listvalues(align, ALIGN_list) 3260 ialign = convert_to_int(align) 3261 ix = convert_to_FL_Coord(x) 3262 iy = convert_to_FL_Coord(y) 3263 iw = convert_to_FL_Coord(w) 3264 ih = convert_to_FL_Coord(h) 3265 ulcolr = convert_to_FL_COLOR(colr) 3266 istyle = convert_to_int(style) 3267 isize = convert_to_int(size) 3268 s_txtstr = convert_to_string(txtstr) 3269 keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 3270 ulcolr, style, istyle, size, isize, txtstr, s_txtstr) 3271 _fl_drw_text(ialign, ix, iy, iw, ih, ulcolr, istyle, isize, 3272 s_txtstr)
3273 3274
3275 -def fl_drw_text_beside(align, x, y, w, h, colr, style, size, txtstr):
3276 """ fl_drw_text_beside(align, x, y, w, h, colr, style, size, txtstr) 3277 """ 3278 3279 _fl_drw_text_beside = cfuncproto( 3280 load_so_libforms(), "fl_drw_text_beside",\ 3281 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 3282 cty.c_int, cty.c_int, STRING],\ 3283 """void fl_drw_text_beside(int align, FL_Coord x, FL_Coord y, 3284 FL_Coord w, FL_Coord h, FL_COLOR c, int style, int size, 3285 const char * str) 3286 """) 3287 check_admitted_listvalues(align, ALIGN_list) 3288 ialign = convert_to_int(align) 3289 ix = convert_to_FL_Coord(x) 3290 iy = convert_to_FL_Coord(y) 3291 iw = convert_to_FL_Coord(w) 3292 ih = convert_to_FL_Coord(h) 3293 ulcolr = convert_to_FL_COLOR(colr) 3294 istyle = convert_to_int(style) 3295 isize = convert_to_int(size) 3296 s_txtstr = convert_to_string(txtstr) 3297 keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 3298 ulcolr, style, istyle, size, isize, txtstr, s_txtstr) 3299 _fl_drw_text_beside(ialign, ix, iy, iw, ih, ulcolr, istyle, 3300 isize, s_txtstr)
3301 3302
3303 -def fl_drw_text_cursor(align, x, y, w, h, colr, style, size, txtstr, cc, pos):
3304 """ fl_drw_text_cursor(align, x, y, w, h, colr, style, size, txtstr, cc, pos) 3305 """ 3306 3307 _fl_drw_text_cursor = cfuncproto( 3308 load_so_libforms(), "fl_drw_text_cursor",\ 3309 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 3310 FL_COLOR, cty.c_int, cty.c_int, STRING, cty.c_int, cty.c_int],\ 3311 """void fl_drw_text_cursor(int align, FL_Coord x, FL_Coord y, 3312 FL_Coord w, FL_Coord h, FL_COLOR c, int style, int size, 3313 const char * str, int cc, int pos) 3314 """) 3315 check_admitted_listvalues(align, ALIGN_list) 3316 ialign = convert_to_int(align) 3317 ix = convert_to_FL_Coord(x) 3318 iy = convert_to_FL_Coord(y) 3319 iw = convert_to_FL_Coord(w) 3320 ih = convert_to_FL_Coord(h) 3321 ulcolr = convert_to_FL_COLOR(colr) 3322 istyle = convert_to_int(style) 3323 isize = convert_to_int(size) 3324 s_txtstr = convert_to_string(txtstr) 3325 icc = convert_to_int(cc) 3326 ipos = convert_to_int(pos) 3327 keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 3328 ulcolr, style, istyle, size, isize, txtstr, s_txtstr, 3329 cc, icc, pos, ipos) 3330 _fl_drw_text_cursor(ialign, ix, iy, iw, ih, ulcolr, istyle, 3331 isize, s_txtstr, icc, ipos)
3332 3333
3334 -def fl_drw_box(style, x, y, w, h, colr, bwIn):
3335 """ fl_drw_box(style, x, y, w, h, colr, bwIn) 3336 """ 3337 3338 _fl_drw_box = cfuncproto( 3339 load_so_libforms(), "fl_drw_box",\ 3340 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 3341 cty.c_int],\ 3342 """void fl_drw_box(int style, FL_Coord x, FL_Coord y, FL_Coord w, 3343 FL_Coord h, FL_COLOR c, int bw_in) 3344 """) 3345 istyle = convert_to_int(style) 3346 ix = convert_to_FL_Coord(x) 3347 iy = convert_to_FL_Coord(y) 3348 iw = convert_to_FL_Coord(w) 3349 ih = convert_to_FL_Coord(h) 3350 ulcolr = convert_to_FL_COLOR(colr) 3351 ibwIn = convert_to_int(bwIn) 3352 keep_elem_refs(style, istyle, x, ix, y, iy, w, iw, h, ih, colr, 3353 ulcolr, bwIn, ibwIn) 3354 _fl_drw_box(style, x, y, w, h, ulcolr, ibwIn)
3355 3356 3357 FL_DRAWPTR = cty.CFUNCTYPE(None, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 3358 cty.c_int, FL_COLOR) 3359
3360 -def fl_add_symbol(name, py_DrawPtr, scalable):
3361 """ 3362 fl_add_symbol(name, py_DrawPtr, scalable) -> num. 3363 3364 Adds a symbol. 3365 3366 @param name : name of a symbol 3367 @param py_DrawPtr : python function to draw symbol, fn(coord, coord, 3368 coord, coord, num, colr) 3369 @param scalable : not used 3370 """ 3371 3372 _fl_add_symbol = cfuncproto( 3373 load_so_libforms(), "fl_add_symbol",\ 3374 cty.c_int, [STRING, FL_DRAWPTR, cty.c_int],\ 3375 """int fl_add_symbol(const char * name, FL_DRAWPTR drawit, 3376 int scalable) 3377 """) 3378 s_name = convert_to_string(name) 3379 iscalable = convert_to_int(scalable) 3380 c_DrawPtr = FL_DRAWPTR(py_DrawPtr) 3381 keep_cfunc_refs(c_DrawPtr, py_DrawPtr) 3382 keep_elem_refs(name, s_name, scalable, iscalable) 3383 retval = _fl_add_symbol(s_name, c_DrawPtr, iscalable) 3384 return retval
3385 3386
3387 -def fl_draw_symbol(label, x, y, w, h, colr):
3388 """ fl_draw_symbol(label, x, y, w, h, colr) -> num. 3389 """ 3390 3391 _fl_draw_symbol = cfuncproto( 3392 load_so_libforms(), "fl_draw_symbol",\ 3393 cty.c_int, [STRING, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 3394 FL_COLOR],\ 3395 """int fl_draw_symbol(const char * label, FL_Coord x, FL_Coord y, 3396 FL_Coord w, FL_Coord h, FL_COLOR col) 3397 """) 3398 slabel = convert_to_string(label) 3399 ix = convert_to_FL_Coord(x) 3400 iy = convert_to_FL_Coord(y) 3401 iw = convert_to_FL_Coord(w) 3402 ih = convert_to_FL_Coord(h) 3403 ulcolr = convert_to_FL_COLOR(colr) 3404 keep_elem_refs(label, slabel, x, ix, y, iy, w, iw, h, ih, colr, 3405 ulcolr) 3406 retval = _fl_draw_symbol(slabel, ix, iy, iw, ih, ulcolr) 3407 return retval
3408 3409
3410 -def fl_mapcolor(colr, r, g, b):
3411 """ fl_mapcolor(colr, r, g, b) -> num. 3412 """ 3413 3414 _fl_mapcolor = cfuncproto( 3415 load_so_libforms(), "fl_mapcolor",\ 3416 cty.c_ulong, [FL_COLOR, cty.c_int, cty.c_int, cty.c_int],\ 3417 """long unsigned int fl_mapcolor(FL_COLOR col, int r, int g, int b) 3418 """) 3419 ulcolr = convert_to_FL_COLOR(colr) 3420 ir = convert_to_int(r) 3421 ig = convert_to_int(g) 3422 ib = convert_to_int(b) 3423 keep_elem_refs(colr, ulcolr, r, ir, g, ig, b, ib) 3424 retval = _fl_mapcolor(ulcolr, ir, ig, ib) 3425 return retval
3426 3427
3428 -def fl_mapcolorname(colr, name):
3429 """ fl_mapcolorname(colr, name) -> num. 3430 """ 3431 3432 _fl_mapcolorname = cfuncproto( 3433 load_so_libforms(), "fl_mapcolorname",\ 3434 cty.c_long, [FL_COLOR, STRING],\ 3435 """long int fl_mapcolorname(FL_COLOR col, const char * name) 3436 """) 3437 ulcolr = convert_to_FL_COLOR(colr) 3438 sname = convert_to_string(name) 3439 keep_elem_refs(colr, ulcolr, name, sname) 3440 retval = _fl_mapcolorname(ulcolr, sname) 3441 return retval
3442 3443 3444 fl_mapcolor_name = fl_mapcolorname 3445 3446
3447 -def fl_free_colors(c, n):
3448 """ fl_free_colors(c, n) 3449 """ 3450 3451 _fl_free_colors = cfuncproto( 3452 load_so_libforms(), "fl_free_colors",\ 3453 None, [cty.POINTER(FL_COLOR), cty.c_int],\ 3454 """void fl_free_colors(FL_COLOR * c, int n) 3455 """) 3456 inum = convert_to_int(n) 3457 keep_elem_refs(c, n, inum) 3458 _fl_free_colors(c, inum)
3459 3460
3461 -def fl_free_pixels(pix, n):
3462 """ fl_free_pixels(pix, n) 3463 """ 3464 3465 _fl_free_pixels = cfuncproto( 3466 load_so_libforms(), "fl_free_pixels",\ 3467 None, [cty.POINTER(cty.c_ulong), cty.c_int],\ 3468 """void fl_free_pixels(long unsigned int * pix, int n) 3469 """) 3470 inum = convert_to_int(n) 3471 keep_elem_refs(pix, n, inum) 3472 _fl_free_pixels(pix, inum)
3473 3474
3475 -def fl_set_color_leak(y):
3476 """ fl_set_color_leak(y) 3477 """ 3478 3479 _fl_set_color_leak = cfuncproto( 3480 load_so_libforms(), "fl_set_color_leak",\ 3481 None, [cty.c_int],\ 3482 """void fl_set_color_leak(int y) 3483 """) 3484 iy = convert_to_int(y) 3485 keep_elem_refs(y, iy) 3486 _fl_set_color_leak(iy)
3487 3488 3489 #def fl_getmcolor(colr, r, g, b) *API change*
3490 -def fl_getmcolor(colr):
3491 """ fl_getmcolor(colr) -> num., r, g,b 3492 """ 3493 3494 _fl_getmcolor = cfuncproto( 3495 load_so_libforms(), "fl_getmcolor",\ 3496 cty.c_ulong, [FL_COLOR, cty.POINTER(cty.c_int),\ 3497 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 3498 """long unsigned int fl_getmcolor(FL_COLOR i, int * r, int * g, 3499 int * b) 3500 """) 3501 check_admitted_listvalues(colr, COLOR_list) 3502 ulcolr = convert_to_FL_COLOR(colr) 3503 r, pr = make_int_and_pointer() 3504 g, pg = make_int_and_pointer() 3505 b, pb = make_int_and_pointer() 3506 keep_elem_refs(colr, ulcolr, r, g, b, pr, pg, pb) 3507 retval = _fl_getmcolor(ulcolr, pr, pg, pb) 3508 return retval, r, g,b
3509 3510
3511 -def fl_get_pixel(colr):
3512 """ fl_get_pixel(colr) -> pixel num. 3513 """ 3514 3515 _fl_get_pixel = cfuncproto( 3516 load_so_libforms(), "fl_get_pixel",\ 3517 cty.c_ulong, [FL_COLOR],\ 3518 """long unsigned int fl_get_pixel(FL_COLOR col) 3519 """) 3520 check_admitted_listvalues(colr, COLOR_list) 3521 ulcolr = convert_to_FL_COLOR(colr) 3522 keep_elem_refs(colr, ulcolr) 3523 retval = _fl_get_pixel(ulcolr) 3524 return retval
3525 3526 3527 fl_get_flcolor = fl_get_pixel 3528 3529 3530 #def fl_get_icm_color(colr, r, g, b) *API change*
3531 -def fl_get_icm_color(colr):
3532 """ fl_get_icm_color(colr) -> r, g,b 3533 """ 3534 3535 _fl_get_icm_color = cfuncproto( 3536 load_so_libforms(), "fl_get_icm_color",\ 3537 None, [FL_COLOR, cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 3538 cty.POINTER(cty.c_int)],\ 3539 """void fl_get_icm_color(FL_COLOR col, int * r, int * g, int * b) 3540 """) 3541 check_admitted_listvalues(colr, COLOR_list) 3542 ulcolr = convert_to_FL_COLOR(colr) 3543 r, pr = make_int_and_pointer() 3544 g, pg = make_int_and_pointer() 3545 b, pb = make_int_and_pointer() 3546 keep_elem_refs(colr, ulcolr, r, g, b, pr, pg, pb) 3547 _fl_get_icm_color(ulcolr, pr, pg, pb) 3548 return r, g,b
3549 3550
3551 -def fl_set_icm_color(colr, r, g, b):
3552 """ fl_set_icm_color(colr, r, g, b) 3553 """ 3554 3555 _fl_set_icm_color = cfuncproto( 3556 load_so_libforms(), "fl_set_icm_color",\ 3557 None, [FL_COLOR, cty.c_int, cty.c_int, cty.c_int],\ 3558 """void fl_set_icm_color(FL_COLOR col, int r, int g, int b) 3559 """) 3560 ulcolr = convert_to_FL_COLOR(colr) 3561 ir = convert_to_int(r) 3562 ig = convert_to_int(g) 3563 ib = convert_to_int(b) 3564 keep_elem_refs(colr, ulcolr, r, g, b, ir, ig, ib) 3565 _fl_set_icm_color(ulcolr, ir, ig, ib)
3566 3567
3568 -def fl_color(colr):
3569 """ fl_color(colr) 3570 """ 3571 3572 _fl_color = cfuncproto( 3573 load_so_libforms(), "fl_color",\ 3574 None, [FL_COLOR],\ 3575 """void fl_color(FL_COLOR col) 3576 """) 3577 check_admitted_listvalues(colr, COLOR_list) 3578 ulcolr = convert_to_FL_COLOR(colr) 3579 keep_elem_refs(colr, ulcolr) 3580 _fl_color(ulcolr)
3581 3582
3583 -def fl_bk_color(colr):
3584 """ fl_bk_color(colr) 3585 """ 3586 3587 _fl_bk_color = cfuncproto( 3588 load_so_libforms(), "fl_bk_color",\ 3589 None, [FL_COLOR],\ 3590 """void fl_bk_color(FL_COLOR col) 3591 """) 3592 check_admitted_listvalues(colr, COLOR_list) 3593 ulcolr = convert_to_FL_COLOR(colr) 3594 keep_elem_refs(colr, ulcolr) 3595 _fl_bk_color(ulcolr)
3596 3597
3598 -def fl_textcolor(colr):
3599 """ fl_textcolor(colr) 3600 """ 3601 3602 _fl_textcolor = cfuncproto( 3603 load_so_libforms(), "fl_textcolor",\ 3604 None, [FL_COLOR],\ 3605 """void fl_textcolor(FL_COLOR col) 3606 """) 3607 check_admitted_listvalues(colr, COLOR_list) 3608 ulcolr = convert_to_FL_COLOR(colr) 3609 keep_elem_refs(colr, ulcolr) 3610 _fl_textcolor(ulcolr)
3611 3612
3613 -def fl_bk_textcolor(colr):
3614 """ fl_bk_textcolor(colr) 3615 """ 3616 3617 _fl_bk_textcolor = cfuncproto( 3618 load_so_libforms(), "fl_bk_textcolor",\ 3619 None, [FL_COLOR],\ 3620 """void fl_bk_textcolor(FL_COLOR col) 3621 """) 3622 check_admitted_listvalues(colr, COLOR_list) 3623 ulcolr = convert_to_FL_COLOR(colr) 3624 keep_elem_refs(colr, ulcolr) 3625 _fl_bk_textcolor(ulcolr)
3626 3627
3628 -def fl_set_gamma(r, g, b):
3629 """ 3630 fl_set_gamma(r, g, b) 3631 3632 @param r : value for red 3633 @param g : value for green 3634 @param b : value for blue 3635 """ 3636 3637 _fl_set_gamma = cfuncproto( 3638 load_so_libforms(), "fl_set_gamma",\ 3639 None, [cty.c_double, cty.c_double, cty.c_double],\ 3640 """void fl_set_gamma(double r, double g, double b) 3641 """) 3642 fr = convert_to_double(r) 3643 fg = convert_to_double(g) 3644 fb = convert_to_double(b) 3645 keep_elem_refs(r, fr, g, fg, b, fb) 3646 _fl_set_gamma(fr, fg, fb)
3647 3648
3649 -def fl_show_errors(y):
3650 """ fl_show_errors(y) 3651 """ 3652 3653 _fl_show_errors = cfuncproto( 3654 load_so_libforms(), "fl_show_errors",\ 3655 None, [cty.c_int],\ 3656 """void fl_show_errors(int y) 3657 """) 3658 iy = convert_to_int(y) 3659 keep_elem_refs(y, iy) 3660 _fl_show_errors(iy)
3661 3662 3663 # Some macros 3664
3665 -def FL_max(a, b):
3666 if (a > b): 3667 return a 3668 else: 3669 return b
3670
3671 -def FL_min(a, b):
3672 if (a < b): 3673 return a 3674 else: 3675 return b
3676
3677 -def FL_abs(a):
3678 if (a > 0): 3679 return a 3680 else: 3681 return (-a)
3682
3683 -def FL_nint(a):
3684 if int(a) > 0: 3685 return (a + 0.5) 3686 else: 3687 return (a - 0.5)
3688
3689 -def FL_clamp(a, amin, amax):
3690 if (a < amin): 3691 return amin 3692 elif (a > amax): 3693 return amax 3694 else: 3695 return a
3696
3697 -def FL_crnd(a):
3698 if FL_Coord(a) > 0: 3699 return (a + 0.5) 3700 else: 3701 return (a - 0.5)
3702 3703 3704 # utilities for new objects 3705
3706 -def fl_add_object(pForm, pObject):
3707 """ 3708 fl_add_object(pForm, pObject) 3709 3710 @param pForm : pointer to form 3711 @param pObject : pointer to object 3712 """ 3713 3714 _fl_add_object = cfuncproto( 3715 load_so_libforms(), "fl_add_object",\ 3716 None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)],\ 3717 """void fl_add_object(FL_FORM * form, FL_OBJECT * obj) 3718 """) 3719 keep_elem_refs(pForm, pObject) 3720 _fl_add_object(pForm, pObject)
3721 3722
3723 -def fl_addto_form(pForm):
3724 """ 3725 fl_addto_form(pForm) -> pForm 3726 3727 Reopens a form for input. 3728 3729 @param pForm : pointer to form 3730 """ 3731 3732 _fl_addto_form = cfuncproto( 3733 load_so_libforms(), "fl_addto_form", 3734 cty.POINTER(FL_FORM), [cty.POINTER(FL_FORM)],\ 3735 """FL_FORM * fl_addto_form(FL_FORM * form) 3736 """) 3737 keep_elem_refs(pForm) 3738 retval = _fl_addto_form(pForm) 3739 return retval
3740 3741
3742 -def fl_make_object(objclass, objtype, x, y, w, h, label, py_HandlePtr):
3743 """ 3744 fl_make_object(objclass, objtype, x, y, w, h, label, py_HandlePtr) -> pObject 3745 """ 3746 3747 _fl_make_object = cfuncproto( 3748 load_so_libforms(), "fl_make_object",\ 3749 cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord,\ 3750 FL_Coord, FL_Coord, FL_Coord, STRING, FL_HANDLEPTR],\ 3751 """FL_OBJECT * fl_make_object(int objclass, int type, FL_Coord x, 3752 FL_Coord y, FL_Coord w, FL_Coord h, const char * label, 3753 FL_HANDLEPTR handle) 3754 """) 3755 iobjclass = convert_to_int(objclass) 3756 iobjtype = convert_to_int(objtype) 3757 ix = convert_to_FL_Coord(x) 3758 iy = convert_to_FL_Coord(y) 3759 iw = convert_to_FL_Coord(w) 3760 ih = convert_to_FL_Coord(h) 3761 slabel = convert_to_string(label) 3762 c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 3763 keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 3764 keep_elem_refs(objclass, objtype, x, y, w, h, label, iobjclass, 3765 iobjtype, ix, iy, iw, ih, slabel) 3766 retval = _fl_make_object(iobjclass, iobjtype, ix, iy, iw, 3767 ih, slabel, c_HandlePtr) 3768 return retval
3769 3770
3771 -def fl_add_child(pObject1, pObject2):
3772 """ 3773 fl_add_child(pObject1, pObject2) 3774 3775 @param pObject1 : pointer to father object 3776 @param pObject2 : pointer to child object 3777 """ 3778 3779 _fl_add_child = cfuncproto( 3780 load_so_libforms(), "fl_add_child",\ 3781 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_OBJECT)],\ 3782 """void fl_add_child(FL_OBJECT * p1, FL_OBJECT * p2) 3783 """) 3784 keep_elem_refs(pObject1, pObject2) 3785 _fl_add_child(pObject1, pObject2)
3786 3787
3788 -def fl_set_coordunit(u):
3789 """ 3790 fl_set_coordunit(u) 3791 3792 @param u :? 3793 """ 3794 3795 _fl_set_coordunit = cfuncproto( 3796 load_so_libforms(), "fl_set_coordunit",\ 3797 None, [cty.c_int],\ 3798 """void fl_set_coordunit(int u) 3799 """) 3800 iu = convert_to_int(u) 3801 keep_elem_refs(u, iu) 3802 _fl_set_coordunit(iu)
3803 3804
3805 -def fl_set_border_width(bw):
3806 """ 3807 fl_set_border_width(bw) 3808 3809 Sets the width of the border. 3810 3811 @param bw : width of border 3812 """ 3813 3814 _fl_set_border_width = cfuncproto( 3815 load_so_libforms(), "fl_set_border_width",\ 3816 None, [cty.c_int],\ 3817 """void fl_set_border_width(int bw) 3818 """) 3819 ibw = convert_to_int(bw) 3820 keep_elem_refs(bw, ibw) 3821 _fl_set_border_width(ibw)
3822 3823
3824 -def fl_set_scrollbar_type(sbtype):
3825 """ 3826 fl_set_scrollbar_type(sbtype) 3827 3828 @param sbtype : type of scrollbar 3829 """ 3830 3831 _fl_set_scrollbar_type = cfuncproto( 3832 load_so_libforms(), "fl_set_scrollbar_type",\ 3833 None, [cty.c_int],\ 3834 """void fl_set_scrollbar_type(int t) 3835 """) 3836 check_admitted_listvalues(sbtype, SCROLLTYPE_list) 3837 isbtype = convert_to_int(sbtype) 3838 keep_elem_refs(sbtype, isbtype) 3839 _fl_set_scrollbar_type(isbtype)
3840 3841
3842 -def fl_set_thinscrollbar(t):
3843 if t: 3844 t_type = FL_THIN_SCROLLBAR 3845 else: 3846 t_type = FL_NORMAL_SCROLLBAR 3847 fl_set_scrollbar_type(t_type)
3848 3849
3850 -def fl_flip_yorigin():
3851 """ fl_flip_yorigin() 3852 """ 3853 3854 _fl_flip_yorigin = cfuncproto( 3855 load_so_libforms(), "fl_flip_yorigin",\ 3856 None, [],\ 3857 """void fl_flip_yorigin() 3858 """) 3859 _fl_flip_yorigin()
3860 3861
3862 -def fl_get_coordunit():
3863 """ fl_get_coordunit() -> coord_unit num. 3864 """ 3865 3866 _fl_get_coordunit = cfuncproto( 3867 load_so_libforms(), "fl_get_coordunit",\ 3868 cty.c_int, [],\ 3869 """int fl_get_coordunit() 3870 """) 3871 retval = _fl_get_coordunit() 3872 return retval
3873 3874
3875 -def fl_get_border_width():
3876 """ fl_get_border_width() -> width num. 3877 """ 3878 3879 _fl_get_border_width = cfuncproto( 3880 load_so_libforms(), "fl_get_border_width",\ 3881 cty.c_int, [],\ 3882 """int fl_get_border_width() 3883 """) 3884 retval = _fl_get_border_width() 3885 return retval
3886 3887 3888 # misc. routines 3889
3890 -def fl_ringbell(percent):
3891 """ 3892 fl_ringbell(percent) 3893 3894 Sounds the keyboard ringbell (if capable). 3895 3896 @param percent : volume value for the bell, min -100 (off), max 100, 3897 0 is default 3898 """ 3899 3900 _fl_ringbell = cfuncproto( 3901 load_so_libforms(), "fl_ringbell",\ 3902 None, [cty.c_int],\ 3903 """void fl_ringbell(int percent) 3904 """) 3905 ipercent = convert_to_int(percent) 3906 keep_elem_refs(percent, ipercent) 3907 _fl_ringbell(ipercent)
3908 3909 3910 #def fl_gettime(sec, usec) *API change*
3911 -def fl_gettime():
3912 """ 3913 fl_gettime() -> sec, usec 3914 3915 Returns the current time, expressed in seconds and microseconds 3916 since 00:00 GMT January, 1970. It is most useful for computing 3917 time differences 3918 """ 3919 3920 _fl_gettime = cfuncproto( 3921 load_so_libforms(), "fl_gettime",\ 3922 None, [cty.POINTER(cty.c_long), cty.POINTER(cty.c_long)],\ 3923 """void fl_gettime(long int * sec, long int * usec) 3924 """) 3925 sec, psec = make_long_and_pointer() 3926 usec, pusec = make_long_and_pointer() 3927 keep_elem_refs(sec, usec, psec, pusec) 3928 _fl_gettime(psec, pusec) 3929 return sec, usec
3930 3931
3932 -def fl_now():
3933 """ 3934 fl_now() -> string 3935 3936 Returns a string form of the current date and time. The format of 3937 the string is of the form "Wed Jun 30 21:49:08 1993" 3938 """ 3939 3940 _fl_now = cfuncproto( 3941 load_so_libforms(), "fl_now",\ 3942 STRING, [],\ 3943 """const char * fl_now() 3944 """) 3945 retval = _fl_now() 3946 return retval
3947 3948
3949 -def fl_whoami():
3950 """ 3951 fl_whoami() -> string 3952 3953 Returns the user name who is running the application. 3954 """ 3955 3956 _fl_whoami = cfuncproto( 3957 load_so_libforms(), "fl_whoami",\ 3958 STRING, [],\ 3959 """const char * fl_whoami() 3960 """) 3961 retval = _fl_whoami() 3962 return retval
3963 3964
3965 -def fl_mouse_button():
3966 """ fl_mouse_button() -> num. 3967 """ 3968 3969 _fl_mouse_button = cfuncproto( 3970 load_so_libforms(), "fl_mouse_button",\ 3971 cty.c_long, [],\ 3972 """long int fl_mouse_button() 3973 """) 3974 retval = _fl_mouse_button() 3975 return retval
3976 3977 fl_mousebutton = fl_mouse_button 3978 3979 3980
3981 -def fl_strdup(strng):
3982 """ fl_strdup(strng) -> string 3983 """ 3984 3985 _fl_strdup = cfuncproto( 3986 load_so_libforms(), "fl_strdup",\ 3987 STRING, [STRING],\ 3988 """char * fl_strdup(const char * s) 3989 """) 3990 sstrng = convert_to_string(strng) 3991 keep_elem_refs(strng, sstrng) 3992 retval = _fl_strdup(sstrng) 3993 return retval
3994 3995
3996 -def fl_set_err_logfp(pFile):
3997 """ fl_set_err_logfp(pFile) 3998 """ 3999 4000 _fl_set_err_logfp = cfuncproto( 4001 load_so_libforms(), "fl_set_err_logfp",\ 4002 None, [cty.POINTER(FILE)],\ 4003 """void fl_set_err_logfp(FILE * fp) 4004 """) 4005 keep_elem_refs(pFile) 4006 _fl_set_err_logfp(pFile)
4007 4008 # This function was called 'fl_set_error_logfp/' in XForms 0.89. 4009 fl_set_error_logfp = fl_set_err_logfp 4010 4011 4012
4013 -def fl_set_error_handler(py_ErrorFunc):
4014 """ 4015 fl_set_error_handler(py_ErrorFunc) 4016 """ 4017 4018 _fl_set_error_handler = cfuncproto( 4019 load_so_libforms(), "fl_set_error_handler",\ 4020 None, [FL_ERROR_FUNC],\ 4021 """void fl_set_error_handler(FL_ERROR_FUNC user_func) 4022 """) 4023 c_ErrorFunc = FL_ERROR_FUNC(py_ErrorFunc) 4024 keep_cfunc_refs(c_ErrorFunc, py_ErrorFunc) 4025 retval = _fl_set_error_handler(c_ErrorFunc) 4026 return retval
4027 4028
4029 -def fl_get_cmdline_args(p1):
4030 """ fl_get_cmdline_args(p1) -> string 4031 """ 4032 4033 _fl_get_cmdline_args = cfuncproto( 4034 load_so_libforms(), "fl_get_cmdline_args",\ 4035 cty.POINTER(STRING), [cty.POINTER(cty.c_int)],\ 4036 """)char * * fl_get_cmdline_args(int * p1) 4037 """) 4038 keep_elem_refs(p1) 4039 retval = _fl_get_cmdline_args(p1) 4040 return retval
4041 4042 4043 # these give more flexibility for future changes. Also application 4044 # can re-assign these pointers to whatever function it wants, e.g., 4045 # to a shared memory pool allocator. 4046 4047 #fl_free = (cty.CFUNCTYPE(None, cty.c_void_p)).in_dll(load_so_libforms(), 'fl_free')
4048 -def fl_free(p1):
4049 """ fl_free(p1) 4050 """ 4051 4052 _fl_free = cfuncproto( 4053 load_so_libforms(), "fl_free",\ 4054 None, [cty.c_void_p], 4055 """void ( * fl_free )( void *) 4056 """) 4057 keep_elem_refs(p1) 4058 _fl_free(p1)
4059 4060 4061 # cfunction for _fl_malloc 4062 cfunc_none_sizet = cty.CFUNCTYPE(cty.c_void_p, size_t) 4063 4064 # low-level function maybe unused in python 4065 ##fl_malloc = (cty.CFUNCTYPE(cty.c_void_p, size_t)).in_dll(load_so_libforms(), 4066 # 'fl_malloc') 4067 #def fl_malloc(size): 4068 # """ fl_malloc(size) -> pointer 4069 # """# 4070 # _fl_malloc = cfuncproto( 4071 # load_so_libforms(), "fl_malloc",\ 4072 # cty.c_void_p, [size_t], 4073 # """void * ( * fl_malloc )( size_t) 4074 # """) 4075 # uisize = convert_to_uint(size) 4076 # keep_elem_refs(size, uisize) 4077 # retval = _fl_malloc(uisize) 4078 # return retval 4079 4080 4081 # cfunction for _fl_calloc 4082 cfunc_none_sizet_sizet = cty.CFUNCTYPE(cty.c_void_p, size_t, size_t) 4083 4084 # low-level function maybe unused in python 4085 ##fl_calloc = (cty.CFUNCTYPE(cty.c_void_p, size_t, size_t)).in_dll(\ 4086 # load_so_libforms(), 'fl_calloc') 4087 #def fl_calloc(size): 4088 # """ fl_calloc(size) -> pointer 4089 # """# 4090 # _fl_calloc = cfuncproto( 4091 # load_so_libforms(), "fl_malloc",\ 4092 # cty.c_void_p, [size_t, size_t], 4093 # """void * ( * fl_calloc )( size_t) 4094 # """) 4095 # uisize = convert_to_uint(size) 4096 # keep_elem_refs(size, uisize) 4097 # retval = _fl_calloc(uisize) 4098 # return retval 4099 4100 4101 # cfunction for _fl_realloc 4102 cfunc_voidp_voidp_sizet = cty.CFUNCTYPE(cty.c_void_p, cty.c_void_p, size_t) 4103 4104 # low-level function maybe unused in python 4105 ##fl_realloc = (cty.CFUNCTYPE(cty.c_void_p, cty.c_void_p, size_t)).in_dll(\ 4106 # load_so_libforms(), 'fl_realloc') 4107 #def fl_realloc(py_p1, size): 4108 # """ fl_realloc(py_p1, size) -> pointer 4109 # """# 4110 # _fl_realloc = cfuncproto( 4111 # load_so_libforms(), "fl_realloc",\ 4112 # cty.c_void_p, [cty.c_void_p, size_t], 4113 # """void * ( * fl_realloc )( void* 4114 # """) 4115 # uisize = convert_to_uint(size) 4116 # c_p1 = cfunc_voidp_voidp_sizet(py_p1) 4117 # keep_cfunc_refs(c_p1) 4118 # keep_elem_refs(size, uisize) 4119 # retval = _fl_realloc(c_p1, uisize) 4120 # return retval 4121 4122
4123 -def fl_msleep(msec):
4124 """ 4125 fl_msleep(msec) -> num. 4126 4127 Waits for a number of milliseconds (with the best resolution 4128 possible on your system) 4129 4130 @param msec : milliseconds to sleep 4131 """ 4132 4133 _fl_msleep = cfuncproto( 4134 load_so_libforms(), "fl_msleep",\ 4135 cty.c_int, [cty.c_ulong],\ 4136 """int fl_msleep(long unsigned int msec) 4137 """) 4138 ulmsec = convert_to_ulong(msec) 4139 keep_elem_refs(msec, ulmsec) 4140 retval = _fl_msleep(ulmsec) 4141 return retval
4142 4143
4144 -def fl_is_same_object(pObject1, pObject2):
4145 """ 4146 fl_is_same_object(pObject1, pObject2) -> num. 4147 4148 Does a comparison between two objects. 4149 """ 4150 4151 _fl_is_same_object = cfuncproto( 4152 load_so_libforms(), "fl_is_same_object", \ 4153 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_OBJECT)], \ 4154 """int fl_is_same_object(FL_OBJECT * obj1, FL_OBJECT * obj2) 4155 """) 4156 keep_elem_refs(pObject1, pObject2) 4157 retval = _fl_is_same_object(pObject1, pObject2) 4158 return retval
4159 4160 4161 4162 ########################### 4163 # forms.h (XBasic.h) 4164 # X Window dependent stuff 4165 ########################### 4166
4167 -def FL_is_gray(v):
4168 if (v == GrayScale) or (v == StaticGray): 4169 return True 4170 else: 4171 return False
4172 4173
4174 -def FL_is_rgb(v):
4175 if (v == TrueColor) or (v == DirectColor): 4176 return True 4177 else: 4178 return False
4179 4180 4181 # Current version only runs in single visual mode
4182 -def fl_get_vclass():
4183 return fl_vmode
4184 4185
4186 -def fl_get_form_vclass(a):
4187 return fl_vmode
4188 4189
4190 -def fl_get_gc():
4191 return fl_state[fl_vmode].gc[0]
4192 4193
4194 -def fl_mode_capable(mode, warn):
4195 """ 4196 fl_mode_capable(mode, warn) -> mode num. 4197 4198 Determines the visual classes the system is capable of. It returns 4199 1 if the system is capable of displaying in this visual class and 4200 0 otherwise. 4201 4202 @param mode : visual mode (i.e. xfc.FL_GrayScale, xfc.FL_StaticGray, 4203 xfc.FL_PseudoColor, xfc.FL_StaticColor, xfc.FL_DirectColor and 4204 xfc.FL_TrueColor) 4205 @param warn : warning (0|1), if set a warning is printed out in case 4206 the capability asked for isn't available 4207 """ 4208 4209 _fl_mode_capable = cfuncproto( 4210 load_so_libforms(), "fl_mode_capable",\ 4211 cty.c_int, [cty.c_int, cty.c_int],\ 4212 """int fl_mode_capable(int mode, int warn) 4213 """) 4214 imode = convert_to_int(mode) 4215 iwarn = convert_to_int(warn) 4216 keep_elem_refs(mode, warn, imode, iwarn) 4217 retval = _fl_mode_capable(imode, iwarn) 4218 return retval
4219 4220
4221 -def fl_default_win():
4222 return fl_state[fl_vmode].trailblazer
4223 4224
4225 -def fl_default_window():
4226 return fl_state[fl_vmode].trailblazer
4227 4228 4229 # Some basic drawing routines 4230 4231 # Rectangles 4232
4233 -def fl_rectangle(fill, x, y, w, h, colr):
4234 """ fl_rectangle(fill, x, y, w, h, colr) 4235 """ 4236 4237 _fl_rectangle = cfuncproto( 4238 load_so_libforms(), "fl_rectangle",\ 4239 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 4240 FL_COLOR],\ 4241 """void fl_rectangle(int fill, FL_Coord x, FL_Coord y, 4242 FL_Coord w, FL_Coord h, FL_COLOR col) 4243 """) 4244 check_admitted_listvalues(colr, COLOR_list) 4245 ifill = convert_to_int(fill) 4246 ix = convert_to_FL_Coord(x) 4247 iy = convert_to_FL_Coord(y) 4248 iw = convert_to_FL_Coord(w) 4249 ih = convert_to_FL_Coord(h) 4250 ulcolr = convert_to_FL_COLOR(colr) 4251 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 4252 ulcolr) 4253 _fl_rectangle(ifill, ix, iy, iw, ih, ulcolr)
4254 4255
4256 -def fl_rectbound(x, y, w, h, colr):
4257 """ fl_rectbound(x, y, w, h, colr) 4258 """ 4259 4260 _fl_rectbound = cfuncproto( 4261 load_so_libforms(), "fl_rectbound",\ 4262 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 4263 """void fl_rectbound(FL_Coord x, FL_Coord y, FL_Coord w, 4264 FL_Coord h, FL_COLOR col) 4265 """) 4266 check_admitted_listvalues(colr, COLOR_list) 4267 ix = convert_to_FL_Coord(x) 4268 iy = convert_to_FL_Coord(y) 4269 iw = convert_to_FL_Coord(w) 4270 ih = convert_to_FL_Coord(h) 4271 ulcolr = convert_to_FL_COLOR(colr) 4272 keep_elem_refs(x, y, w, h, colr, ix, iy, iw, ih, ulcolr) 4273 _fl_rectbound(ix, iy, iw, ih, ulcolr)
4274 4275
4276 -def fl_rectf(x, y, w, h, colr):
4277 fl_rectangle(1, x, y, w, h, colr)
4278 4279
4280 -def fl_rect(x, y, w, h, colr):
4281 fl_rectangle(0, x, y, w, h, colr)
4282 4283 4284 # Rectangle with rounded-corners 4285
4286 -def fl_roundrectangle(fill, x, y, w, h, colr):
4287 """ fl_roundrectangle(fill, x, y, w, h, colr) 4288 """ 4289 4290 _fl_roundrectangle = cfuncproto( 4291 load_so_libforms(), "fl_roundrectangle",\ 4292 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 4293 FL_COLOR],\ 4294 """void fl_roundrectangle(int fill, FL_Coord x, FL_Coord y, 4295 FL_Coord w, FL_Coord h, FL_COLOR col) 4296 """) 4297 check_admitted_listvalues(colr, COLOR_list) 4298 ifill = convert_to_int(fill) 4299 ix = convert_to_FL_Coord(x) 4300 iy = convert_to_FL_Coord(y) 4301 iw = convert_to_FL_Coord(w) 4302 ih = convert_to_FL_Coord(h) 4303 ulcolr = convert_to_FL_COLOR(colr) 4304 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 4305 ulcolr) 4306 _fl_roundrectangle(ifill, ix, iy, iw, ih, ulcolr)
4307 4308
4309 -def fl_roundrectf(x, y, w, h, colr):
4310 fl_roundrectangle(1, x, y, w, h, colr)
4311 4312
4313 -def fl_roundrect(x, y, w, h, colr):
4314 fl_roundrectangle(0, x, y, w, h, colr)
4315 4316 4317 # General polygon and polylines 4318
4319 -def fl_polygon(fill, pPoint, n, colr):
4320 """ fl_polygon(fill, pPoint, n, colr) 4321 """ 4322 4323 _fl_polygon = cfuncproto( 4324 load_so_libforms(), "fl_polygon",\ 4325 None, [cty.c_int, cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 4326 """void fl_polygon(int fill, FL_POINT * xp, int n, FL_COLOR col) 4327 """) 4328 check_admitted_listvalues(colr, COLOR_list) 4329 ifill = convert_to_int(fill) 4330 inum = convert_to_int(n) 4331 ulcolr = convert_to_FL_COLOR(colr) 4332 keep_elem_refs(fill, pPoint, n, colr, ifill, inum, ulcolr) 4333 _fl_polygon(ifill, pPoint, inum, ulcolr)
4334 4335
4336 -def fl_polyf(pPoint, n, colr):
4337 fl_polygon(1, pPoint, n, colr)
4338 4339
4340 -def fl_polyl(pPoint, n, colr):
4341 fl_polygon(0, pPoint, n, colr)
4342
4343 -def fl_polybound(pPoint, n, colr):
4344 fl_polygon(1, pPoint, n, colr) 4345 fl_polygon(0, pPoint, n, FL_BLACK)
4346 4347
4348 -def fl_lines(pPoint, n, colr):
4349 """ fl_lines(pPoint, n, colr) 4350 """ 4351 4352 _fl_lines = cfuncproto( 4353 load_so_libforms(), "fl_lines",\ 4354 None, [cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 4355 """void fl_lines(FL_POINT * xp, int n, FL_COLOR col) 4356 """) 4357 check_admitted_listvalues(colr, COLOR_list) 4358 inum = convert_to_int(n) 4359 ulcolr = convert_to_FL_COLOR(colr) 4360 keep_elem_refs(pPoint, n, colr, inum, ulcolr) 4361 _fl_lines(pPoint, inum, ulcolr)
4362 4363
4364 -def fl_line(xi, yi, xf, yf, colr):
4365 """ fl_line(xi, yi, xf, yf, colr) 4366 """ 4367 4368 _fl_line = cfuncproto( 4369 load_so_libforms(), "fl_line",\ 4370 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 4371 """void fl_line(FL_Coord xi, FL_Coord yi, FL_Coord xf, 4372 FL_Coord yf, FL_COLOR c) 4373 """) 4374 check_admitted_listvalues(colr, COLOR_list) 4375 ixi = convert_to_int(xi) 4376 iyi = convert_to_int(yi) 4377 ixf = convert_to_int(xf) 4378 iyf = convert_to_int(yf) 4379 ulcolr = convert_to_FL_COLOR(colr) 4380 keep_elem_refs(xi, yi, xf, yf, colr, ixi, iyi, ixf, iyf, ulcolr) 4381 _fl_line(ixi, iyi, ixf, iyf, ulcolr)
4382 4383
4384 -def fl_point(x, y, colr):
4385 """ fl_point(x, y, colr) 4386 """ 4387 4388 _fl_point = cfuncproto( 4389 load_so_libforms(), "fl_point",\ 4390 None, [FL_Coord, FL_Coord, FL_COLOR],\ 4391 """void fl_point(FL_Coord x, FL_Coord y, FL_COLOR c) 4392 """) 4393 check_admitted_listvalues(colr, COLOR_list) 4394 ix = convert_to_FL_Coord(x) 4395 iy = convert_to_FL_Coord(y) 4396 ulcolr = convert_to_FL_COLOR(colr) 4397 keep_elem_refs(x, y, colr, ix, iy, ulcolr) 4398 _fl_point(ix, iy, ulcolr)
4399 4400
4401 -def fl_points(pPoint, np, colr):
4402 """ fl_points(pPoint, np, colr) 4403 """ 4404 4405 _fl_points = cfuncproto( 4406 load_so_libforms(), "fl_points",\ 4407 None, [cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 4408 """void fl_points(FL_POINT * p, int np, FL_COLOR c) 4409 """) 4410 check_admitted_listvalues(colr, COLOR_list) 4411 inump = convert_to_int(np) 4412 ulcolr = convert_to_FL_COLOR(colr) 4413 keep_elem_refs(pPoint, np, colr, inump, ulcolr) 4414 _fl_points(pPoint, inump, ulcolr)
4415 4416 4417 fl_simple_line = fl_line 4418 4419
4420 -def fl_dashedlinestyle(dash, ndash):
4421 """ fl_dashedlinestyle(dash, ndash) 4422 """ 4423 4424 _fl_dashedlinestyle = cfuncproto( 4425 load_so_libforms(), "fl_dashedlinestyle",\ 4426 None, [STRING, cty.c_int],\ 4427 """void fl_dashedlinestyle(const char * dash, int ndash) 4428 """) 4429 sdash = convert_to_string(dash) 4430 indash = convert_to_int(ndash) 4431 keep_elem_refs(dash, ndash, sdash, indash) 4432 _fl_dashedlinestyle(sdash, indash)
4433 4434
4435 -def fl_update_display(block):
4436 """ fl_update_display(block) 4437 """ 4438 4439 _fl_update_display = cfuncproto( 4440 load_so_libforms(), "fl_update_display",\ 4441 None, [cty.c_int],\ 4442 """void fl_update_display(int block) 4443 """) 4444 iblock = convert_to_int(block) 4445 keep_elem_refs(block, iblock) 4446 _fl_update_display(iblock)
4447 4448
4449 -def fl_diagline(x, y, w, h, colr):
4450 fl_line(x, y, (x) + (w) - 1, (y) + (h) - 1, colr)
4451 4452 4453 # Line attributes 4454
4455 -def fl_linewidth(n):
4456 """ fl_linewidth(n) 4457 """ 4458 4459 _fl_linewidth = cfuncproto( 4460 load_so_libforms(), "fl_linewidth",\ 4461 None, [cty.c_int],\ 4462 """void fl_linewidth(int n) 4463 """) 4464 inum = convert_to_int(n) 4465 keep_elem_refs(n, inum) 4466 _fl_linewidth(inum)
4467 4468
4469 -def fl_linestyle(n):
4470 """ fl_linestyle(n) 4471 """ 4472 4473 _fl_linestyle = cfuncproto( 4474 load_so_libforms(), "fl_linestyle",\ 4475 None, [cty.c_int],\ 4476 """void fl_linestyle(int n) 4477 """) 4478 inum = convert_to_int(n) 4479 keep_elem_refs(n, inum) 4480 _fl_linestyle(inum)
4481 4482
4483 -def fl_drawmode(request):
4484 """ fl_drawmode(request) 4485 """ 4486 4487 _fl_drawmode = cfuncproto( 4488 load_so_libforms(), "fl_drawmode",\ 4489 None, [cty.c_int],\ 4490 """void fl_drawmode(int request) 4491 """) 4492 irequest = convert_to_int(request) 4493 keep_elem_refs(request, irequest) 4494 _fl_drawmode(irequest)
4495 4496
4497 -def fl_get_linewidth():
4498 """ fl_get_linewidth() -> width num. 4499 """ 4500 4501 _fl_get_linewidth = cfuncproto( 4502 load_so_libforms(), "fl_get_linewidth",\ 4503 cty.c_int, [],\ 4504 """int fl_get_linewidth() 4505 """) 4506 retval = _fl_get_linewidth() 4507 return retval
4508 4509
4510 -def fl_get_linestyle():
4511 """ fl_get_linestyle() -> style num. 4512 """ 4513 4514 _fl_get_linestyle = cfuncproto( 4515 load_so_libforms(), "fl_get_linestyle",\ 4516 cty.c_int, [],\ 4517 """int fl_get_linestyle() 4518 """) 4519 retval = _fl_get_linestyle() 4520 return retval
4521 4522
4523 -def fl_get_drawmode():
4524 """ fl_get_drawmode() -> mode num. 4525 """ 4526 4527 _fl_get_drawmode = cfuncproto( 4528 load_so_libforms(), "fl_get_drawmode",\ 4529 cty.c_int, [],\ 4530 """int fl_get_drawmode() 4531 """) 4532 retval = _fl_get_drawmode() 4533 return retval
4534 4535 4536 fl_set_linewidth = fl_linewidth 4537 fl_set_linestyle = fl_linestyle 4538 fl_set_drawmode = fl_drawmode 4539 4540 4541 # Ellipses 4542
4543 -def fl_oval(fill, x, y, w, h, colr):
4544 """ fl_oval(fill, x, y, w, h, colr) 4545 """ 4546 4547 _fl_oval = cfuncproto( 4548 load_so_libforms(), "fl_oval",\ 4549 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 4550 FL_COLOR],\ 4551 """void fl_oval(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 4552 FL_Coord h, FL_COLOR col) 4553 """) 4554 check_admitted_listvalues(colr, COLOR_list) 4555 ifill = convert_to_int(fill) 4556 ix = convert_to_FL_Coord(x) 4557 iy = convert_to_FL_Coord(y) 4558 iw = convert_to_FL_Coord(w) 4559 ih = convert_to_FL_Coord(h) 4560 ulcolr = convert_to_FL_COLOR(colr) 4561 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 4562 ulcolr) 4563 _fl_oval(ifill, ix, iy, iw, ih, ulcolr)
4564 4565
4566 -def fl_ovalbound(x, y, w, h, colr):
4567 """ fl_ovalbound(x, y, w, h, colr) 4568 """ 4569 4570 _fl_ovalbound = cfuncproto( 4571 load_so_libforms(), "fl_ovalbound",\ 4572 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 4573 """void fl_ovalbound(FL_Coord x, FL_Coord y, FL_Coord w, 4574 FL_Coord h, FL_COLOR col) 4575 """) 4576 check_admitted_listvalues(colr, COLOR_list) 4577 ix = convert_to_FL_Coord(x) 4578 iy = convert_to_FL_Coord(y) 4579 iw = convert_to_FL_Coord(w) 4580 ih = convert_to_FL_Coord(h) 4581 ulcolr = convert_to_FL_COLOR(colr) 4582 keep_elem_refs(x, y, w, h, colr, ix, iy, iw, ih, ulcolr) 4583 _fl_ovalbound(ix, iy, iw, ih, ulcolr)
4584 4585
4586 -def fl_ovalarc(fill, x, y, w, h, t0, dt, colr):
4587 """ fl_ovalarc(fill, x, y, w, h, t0, dt, colr) 4588 """ 4589 4590 _fl_ovalarc = cfuncproto( 4591 load_so_libforms(), "fl_ovalarc",\ 4592 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 4593 cty.c_int, cty.c_int, FL_COLOR],\ 4594 """void fl_ovalarc(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 4595 FL_Coord h, int t0, int dt, FL_COLOR col) 4596 """) 4597 check_admitted_listvalues(colr, COLOR_list) 4598 ifill = convert_to_int(fill) 4599 ix = convert_to_FL_Coord(x) 4600 iy = convert_to_FL_Coord(y) 4601 iw = convert_to_FL_Coord(w) 4602 ih = convert_to_FL_Coord(h) 4603 it0 = convert_to_int(t0) 4604 idt = convert_to_int(dt) 4605 ulcolr = convert_to_FL_COLOR(colr) 4606 keep_elem_refs(fill, x, y, w, h, t0, dt, colr, ifill, ix, iy, iw, 4607 ih, it0, idt, ulcolr) 4608 _fl_ovalarc(ifill, ix, iy, iw, ih, it0, idt, ulcolr)
4609 4610
4611 -def fl_ovalf(x, y, w, h, colr):
4612 fl_oval(1, x, y, w, h, colr)
4613 4614
4615 -def fl_ovall(x, y, w, h, colr):
4616 fl_oval(0, x, y, w, h, colr)
4617 4618 4619 fl_oval_bound = fl_ovalbound 4620 4621
4622 -def fl_circf(x, y, r, colr):
4623 fl_oval(1, (x) - (r), (y) - (r), 2 * (r), 2 * (r), colr)
4624 4625
4626 -def fl_circ( x, y, r, colr):
4627 fl_oval(0, (x) - (r), (y) - (r), 2 * (r), 2 * (r), colr)
4628 4629 4630 # Arcs 4631
4632 -def fl_pieslice(fill, x, y, w, h, a1, a2, colr):
4633 """ fl_pieslice(fill, x, y, w, h, a1, a2, colr) 4634 """ 4635 4636 _fl_pieslice = cfuncproto( 4637 load_so_libforms(), "fl_pieslice",\ 4638 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 4639 cty.c_int, cty.c_int, FL_COLOR],\ 4640 """void fl_pieslice(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 4641 FL_Coord h, int a1, int a2, FL_COLOR col) 4642 """) 4643 check_admitted_listvalues(colr, COLOR_list) 4644 ifill = convert_to_int(fill) 4645 ix = convert_to_FL_Coord(x) 4646 iy = convert_to_FL_Coord(y) 4647 iw = convert_to_FL_Coord(w) 4648 ih = convert_to_FL_Coord(h) 4649 ia1 = convert_to_int(a1) 4650 ia2 = convert_to_int(a2) 4651 ulcolr = convert_to_FL_COLOR(colr) 4652 keep_elem_refs(fill, x, y, w, h, a1, a2, colr, ifill, ix, iy, iw, 4653 ih, ia1, ia2, ulcolr) 4654 _fl_pieslice(ifill, ix, iy, iw, ih, ia1, ia2, ulcolr)
4655 4656
4657 -def fl_arcf(x, y, r, a1, a2, colr):
4658 fl_pieslice(1, (x - r), (y - r), (2 * r), (2 * r), a1, a2, colr)
4659 4660
4661 -def fl_arc(x, y, r, a1, a2, colr):
4662 fl_pieslice(0, (x - r), (y - r), (2 * r), (2 * r), a1, a2, colr)
4663 4664 4665 # High level drawing routines 4666
4667 -def fl_drw_frame(style, x, y, w, h, colr, bw):
4668 """ fl_drw_frame(style, x, y, w, h, colr, bw) 4669 """ 4670 4671 _fl_drw_frame = cfuncproto( 4672 load_so_libforms(), "fl_drw_frame",\ 4673 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 4674 FL_COLOR, cty.c_int],\ 4675 """void fl_drw_frame(int style, FL_Coord x, FL_Coord y, 4676 FL_Coord w, FL_Coord h, FL_COLOR c, int bw) 4677 """) 4678 check_admitted_listvalues(colr, COLOR_list) 4679 istyle = convert_to_int(style) 4680 ix = convert_to_FL_Coord(x) 4681 iy = convert_to_FL_Coord(y) 4682 iw = convert_to_FL_Coord(w) 4683 ih = convert_to_FL_Coord(h) 4684 ulcolr = convert_to_FL_COLOR(colr) 4685 ibw = convert_to_int(bw) 4686 keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, 4687 ih, ulcolr, ibw) 4688 _fl_drw_frame(istyle, ix, iy, iw, ih, ulcolr, ibw)
4689 4690
4691 -def fl_drw_checkbox(boxtype, x, y, w, h, colr, bw):
4692 """ fl_drw_checkbox(boxtype, x, y, w, h, colr, bw) 4693 """ 4694 4695 _fl_drw_checkbox = cfuncproto( 4696 load_so_libforms(), "fl_drw_checkbox",\ 4697 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 4698 FL_COLOR, cty.c_int],\ 4699 """void fl_drw_checkbox(int type, FL_Coord x, FL_Coord y, 4700 FL_Coord w, FL_Coord h, FL_COLOR col, int bw) 4701 """) 4702 check_admitted_listvalues(colr, COLOR_list) 4703 iboxtype = convert_to_int(boxtype) 4704 ix = convert_to_FL_Coord(x) 4705 iy = convert_to_FL_Coord(y) 4706 iw = convert_to_FL_Coord(w) 4707 ih = convert_to_FL_Coord(h) 4708 ulcolr = convert_to_FL_COLOR(colr) 4709 ibw = convert_to_int(bw) 4710 keep_elem_refs(boxtype, x, y, w, h, colr, bw, iboxtype, ix, iy, iw, 4711 ih, ulcolr, ibw) 4712 _fl_drw_checkbox(iboxtype, ix, iy, iw, ih, ulcolr, ibw)
4713 4714 4715 # Interfaces 4716
4717 -def fl_get_fontstruct(style, size):
4718 """ fl_get_fontstruct(style, size) -> XFontStruct class 4719 """ 4720 4721 _fl_get_fontstruct = cfuncproto( 4722 load_so_libforms(), "fl_get_fontstruct",\ 4723 cty.POINTER(XFontStruct), [cty.c_int, cty.c_int],\ 4724 """)XFontStruct * fl_get_fontstruct(int style, int size) 4725 """) 4726 istyle = convert_to_int(style) 4727 isize = convert_to_int(size) 4728 keep_elem_refs(style, size, istyle, isize) 4729 retval = _fl_get_fontstruct(istyle, isize) 4730 return retval
4731 4732 4733 fl_get_font_struct = fl_get_fontstruct 4734 fl_get_fntstruct = fl_get_font_struct 4735 4736 4737 #def fl_get_mouse(x, y, keymask) *API change*
4738 -def fl_get_mouse():
4739 """ fl_get_mouse() -> window, x, y, keymask 4740 """ 4741 4742 _fl_get_mouse = cfuncproto( 4743 load_so_libforms(), "fl_get_mouse",\ 4744 Window, [cty.POINTER(FL_Coord), cty.POINTER(FL_Coord),\ 4745 cty.POINTER(cty.c_uint)],\ 4746 """Window fl_get_mouse(FL_Coord * x, FL_Coord * y, 4747 unsigned int * keymask) 4748 """) 4749 x, px = make_FL_Coord_and_pointer() 4750 y, py = make_FL_Coord_and_pointer() 4751 keymask, pkeymask = make_uint_and_pointer() 4752 keep_elem_refs(x, y, keymask, px, py, pkeymask) 4753 retval = _fl_get_mouse(px, py, pkeymask) 4754 return retval, x, y, keymask
4755 4756
4757 -def fl_set_mouse(mx, my):
4758 """ fl_set_mouse(mx, my) 4759 """ 4760 4761 _fl_set_mouse = cfuncproto( 4762 load_so_libforms(), "fl_set_mouse",\ 4763 None, [FL_Coord, FL_Coord],\ 4764 """void fl_set_mouse(FL_Coord mx, FL_Coord my) 4765 """) 4766 imx = convert_to_int(mx) 4767 imy = convert_to_int(my) 4768 keep_elem_refs(mx, my, imx, imy) 4769 _fl_set_mouse(imx, imy)
4770 4771 4772 #def fl_get_win_mouse(win, x, y, keymask) *API change*
4773 -def fl_get_win_mouse(win):
4774 """ fl_get_win_mouse(win) -> window, x, y, keymask 4775 """ 4776 4777 _fl_get_win_mouse = cfuncproto( 4778 load_so_libforms(), "fl_get_win_mouse",\ 4779 Window, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord),\ 4780 cty.POINTER(cty.c_uint)],\ 4781 """Window fl_get_win_mouse(Window win, FL_Coord * x, FL_Coord * y, 4782 unsigned int * keymask) 4783 """) 4784 ulwin = convert_to_Window(win) 4785 x, px = make_FL_Coord_and_pointer() 4786 y, py = make_FL_Coord_and_pointer() 4787 keymask, pkeymask = make_uint_and_pointer() 4788 keep_elem_refs(win, x, y, keymask, ulwin, px, py, pkeymask) 4789 retval = _fl_get_win_mouse(ulwin, px, py, pkeymask) 4790 return retval, x, y, keymask
4791 4792 4793 #def fl_get_form_mouse(fm, x, y, keymask) *API change*
4794 -def fl_get_form_mouse(pForm):
4795 """ fl_get_form_mouse(pForm) -> window, x, y, keymask 4796 4797 @param pForm : pointer to form 4798 """ 4799 4800 _fl_get_form_mouse = cfuncproto( 4801 load_so_libforms(), "fl_get_form_mouse",\ 4802 Window, [cty.POINTER(FL_FORM), cty.POINTER(FL_Coord),\ 4803 cty.POINTER(FL_Coord), cty.POINTER(cty.c_uint)],\ 4804 """Window fl_get_form_mouse(FL_FORM * fm, FL_Coord * x, 4805 FL_Coord * y, unsigned int * keymask) 4806 """) 4807 x, px = make_FL_Coord_and_pointer() 4808 y, py = make_FL_Coord_and_pointer() 4809 keymask, pkeymask = make_uint_and_pointer() 4810 keep_elem_refs(pForm, x, y, keymask) 4811 retval = _fl_get_form_mouse(pForm, px, py, pkeymask) 4812 return retval, x, y, keymask
4813 4814
4815 -def fl_win_to_form(win):
4816 """ 4817 fl_win_to_form(win) -> pForm 4818 4819 Returns the form that's shown in win. 4820 4821 @param win : window id whose form is shown 4822 """ 4823 4824 _fl_win_to_form = cfuncproto( 4825 load_so_libforms(), "fl_win_to_form", 4826 cty.POINTER(FL_FORM), [Window],\ 4827 """FL_FORM * fl_win_to_form(Window win) 4828 """) 4829 ulwin = convert_to_Window(win) 4830 keep_elem_refs(win, ulwin) 4831 retval = _fl_win_to_form(ulwin) 4832 return retval
4833 4834
4835 -def fl_set_form_icon(pForm, icon, mask):
4836 """ fl_set_form_icon(pForm, icon, mask) 4837 4838 @param pForm : pointer to form 4839 """ 4840 4841 _fl_set_form_icon = cfuncproto( 4842 load_so_libforms(), "fl_set_form_icon",\ 4843 None, [cty.POINTER(FL_FORM), Pixmap, Pixmap],\ 4844 """void fl_set_form_icon(FL_FORM * form, Pixmap p, Pixmap m) 4845 """) 4846 ulicon = convert_to_Pixmap(icon) 4847 ulmask = convert_to_Pixmap(mask) 4848 keep_elem_refs(pForm, icon, mask, ulicon, ulmask) 4849 _fl_set_form_icon(pForm, ulicon, ulmask)
4850 4851 4852 #def fl_get_decoration_sizes(pForm, top, right, bottom, left) *API change*
4853 -def fl_get_decoration_sizes(pForm):
4854 """ 4855 fl_get_decoration_sizes(pForm) -> num., top, right, bottom, left 4856 4857 Returns the sizes of the "decorations" the window manager puts around 4858 a form's window. Returns 0 on success and 1 if the form isn't visible 4859 or it's a form embedded into another form. 4860 4861 @param pForm : pointer to form 4862 """ 4863 4864 _fl_get_decoration_sizes = cfuncproto( 4865 load_so_libforms(), "fl_get_decoration_sizes", 4866 cty.c_int, [cty.POINTER(FL_FORM), cty.POINTER(cty.c_int),\ 4867 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 4868 cty.POINTER(cty.c_int)],\ 4869 """int fl_get_decoration_sizes(FL_FORM * form, int * top, 4870 int * right, int * bottom, int * left) 4871 """) 4872 top, ptop = make_int_and_pointer() 4873 right, pright = make_int_and_pointer() 4874 bottom, pbottom = make_int_and_pointer() 4875 left, pleft = make_int_and_pointer() 4876 keep_elem_refs(pForm, top, right, bottom, left, ptop, pright, pbottom, 4877 pleft) 4878 retval = _fl_get_decoration_sizes(pForm, ptop, pright, pbottom, pleft) 4879 return retval, top, right, bottom, left
4880 4881
4882 -def fl_raise_form(pForm):
4883 """ 4884 fl_raise_form(pForm) 4885 4886 @param pForm : pouinter to form to be raised 4887 """ 4888 4889 _fl_raise_form = cfuncproto( 4890 load_so_libforms(), "fl_raise_form",\ 4891 None, [cty.POINTER(FL_FORM)],\ 4892 """void fl_raise_form(FL_FORM * p1) 4893 """) 4894 keep_elem_refs(pForm) 4895 _fl_raise_form(pForm)
4896 4897
4898 -def fl_lower_form(pForm):
4899 """ 4900 fl_lower_form(pForm) 4901 4902 @param pForm : pouinter to form to be lowered 4903 """ 4904 4905 _fl_lower_form = cfuncproto( 4906 load_so_libforms(), "fl_lower_form",\ 4907 None, [cty.POINTER(FL_FORM)],\ 4908 """void fl_lower_form(FL_FORM * p1) 4909 """) 4910 keep_elem_refs(pForm) 4911 _fl_lower_form(pForm)
4912 4913
4914 -def fl_set_foreground(gc, colr):
4915 """ 4916 fl_set_foreground(gc, colr) 4917 4918 @param gc : ? 4919 @param colr : color value to be set as foreground 4920 """ 4921 4922 _fl_set_foreground = cfuncproto( 4923 load_so_libforms(), "fl_set_foreground",\ 4924 None, [GC, FL_COLOR],\ 4925 """oid fl_set_foreground(GC gc, FL_COLOR col) 4926 """) 4927 ulcolr = convert_to_FL_COLOR(colr) 4928 keep_elem_refs(gc, colr, ulcolr) 4929 _fl_set_foreground(gc, ulcolr)
4930 4931
4932 -def fl_set_background(gc, colr):
4933 """ 4934 fl_set_background(gc, colr) 4935 4936 @param gc : ? 4937 @param colr : color value to be set as background 4938 """ 4939 4940 _fl_set_background = cfuncproto( 4941 load_so_libforms(), "fl_set_background",\ 4942 None, [GC, FL_COLOR],\ 4943 """oid fl_set_background(GC gc, FL_COLOR col) 4944 """) 4945 ulcolr = convert_to_FL_COLOR(colr) 4946 keep_elem_refs(gc, colr, ulcolr) 4947 _fl_set_background(gc, ulcolr)
4948 4949 4950 # General windowing support 4951
4952 -def fl_wincreate(title):
4953 """ 4954 fl_wincreate(title) -> window ID 4955 4956 Creates a window with a specified title. 4957 4958 @param title : title of the window 4959 """ 4960 4961 _fl_wincreate = cfuncproto( 4962 load_so_libforms(), "fl_wincreate",\ 4963 Window, [STRING],\ 4964 """Window fl_wincreate(const char * label) 4965 """) 4966 stitle = convert_to_string(title) 4967 keep_elem_refs(title, stitle) 4968 retval = _fl_wincreate(stitle) 4969 return retval
4970 4971
4972 -def fl_winshow(win):
4973 """ 4974 fl_winshow(win) -> window 4975 4976 Shows the window (created with fl_wincreate) 4977 4978 @param win : window id to show 4979 """ 4980 4981 _fl_winshow = cfuncproto( 4982 load_so_libforms(), "fl_winshow",\ 4983 Window, [Window],\ 4984 """Window fl_winshow(Window win) 4985 """) 4986 ulwin = convert_to_Window(win) 4987 keep_elem_refs(win, ulwin) 4988 retval = _fl_winshow(ulwin) 4989 return retval
4990 4991
4992 -def fl_winopen(title):
4993 """ 4994 fl_winopen(title) -> window 4995 Opens (creates and shows) a toplevel window with the specified 4996 title. 4997 4998 @param title : title of the window 4999 """ 5000 5001 _fl_winopen = cfuncproto( 5002 load_so_libforms(), "fl_winopen", \ 5003 Window, [STRING], \ 5004 """Window fl_winopen(const char * label) 5005 """) 5006 stitle = convert_to_string(title) 5007 keep_elem_refs(title, stitle) 5008 retval = _fl_winopen(stitle) 5009 return retval
5010 5011
5012 -def fl_winhide(win):
5013 """ fl_winhide(win) 5014 """ 5015 5016 _fl_winhide = cfuncproto( 5017 load_so_libforms(), "fl_winhide", \ 5018 None, [Window], \ 5019 """void fl_winhide(Window win) 5020 """) 5021 ulwin = convert_to_Window(win) 5022 keep_elem_refs(win, ulwin) 5023 _fl_winhide(ulwin)
5024 5025
5026 -def fl_winclose(win):
5027 """ fl_winclose(win) 5028 """ 5029 5030 _fl_winclose = cfuncproto( 5031 load_so_libforms(), "fl_winclose", \ 5032 None, [Window], \ 5033 """void fl_winclose(Window win) 5034 """) 5035 ulwin = convert_to_Window(win) 5036 keep_elem_refs(win, ulwin) 5037 _fl_winclose(win, ulwin)
5038 5039
5040 -def fl_winset(win):
5041 """ fl_winset(win) 5042 """ 5043 5044 _fl_winset = cfuncproto( 5045 load_so_libforms(), "fl_winset", \ 5046 None, [Window], \ 5047 """void fl_winset(Window win) 5048 """) 5049 ulwin = convert_to_Window(win) 5050 keep_elem_refs(win, ulwin) 5051 _fl_winset(ulwin)
5052 5053
5054 -def fl_winreparent(win, winnewparent):
5055 """ 5056 fl_winreparent(win, winnewparent) -> num. 5057 5058 Makes a toplevel window a subwindow of another (new parent) window; 5059 both the window and the parent window must be valid ones. 5060 5061 @param win : window to be made a subwindow 5062 @param winnewparent : window to become its new parent window 5063 """ 5064 5065 _fl_winreparent = cfuncproto( 5066 load_so_libforms(), "fl_winreparent", \ 5067 cty.c_int, [Window, Window], \ 5068 """int fl_winreparent(Window win, Window new_parent) 5069 """) 5070 ulwin = convert_to_Window(win) 5071 ulwinnewparent = convert_to_Window(winnewparent) 5072 keep_elem_refs(win, winnewparent, ulwin, ulwinnewparent) 5073 retval = _fl_winreparent(ulwin, ulwinnewparent) 5074 return retval
5075 5076
5077 -def fl_winfocus(win):
5078 """ fl_winfocus(win) 5079 """ 5080 5081 _fl_winfocus = cfuncproto( 5082 load_so_libforms(), "fl_winfocus", \ 5083 None, [Window], \ 5084 """void fl_winfocus(Window win) 5085 """) 5086 ulwin = convert_to_Window(win) 5087 keep_elem_refs(win, ulwin) 5088 _fl_winfocus(ulwin)
5089 5090
5091 -def fl_winget():
5092 """ fl_winget() -> window 5093 """ 5094 5095 _fl_winget = cfuncproto( 5096 load_so_libforms(), "fl_winget", \ 5097 Window, [], \ 5098 """Window fl_winget() 5099 """) 5100 retval = _fl_winget() 5101 return retval
5102 5103
5104 -def fl_iconify(win):
5105 """ fl_iconify(win) -> num. 5106 """ 5107 5108 _fl_iconify = cfuncproto( 5109 load_so_libforms(), "fl_iconify", \ 5110 cty.c_int, [Window], \ 5111 """int fl_iconify(Window win) 5112 """) 5113 ulwin = convert_to_Window(win) 5114 keep_elem_refs(win, ulwin) 5115 retval = _fl_iconify(ulwin) 5116 return retval
5117 5118
5119 -def fl_winresize(win, neww, newh):
5120 """ fl_winresize(win, neww, newh) 5121 5122 @param win : window to resize 5123 @param neww : new width 5124 @param newh : new height 5125 """ 5126 5127 _fl_winresize = cfuncproto( 5128 load_so_libforms(), "fl_winresize", \ 5129 None, [Window, FL_Coord, FL_Coord], \ 5130 """void fl_winresize(Window win, FL_Coord neww, FL_Coord newh) 5131 """) 5132 ulwin = convert_to_Window(win) 5133 ineww = convert_to_int(neww) 5134 inewh = convert_to_int(newh) 5135 keep_elem_refs(win, neww, newh, ulwin, ineww, inewh) 5136 _fl_winresize(ulwin, ineww, inewh)
5137 5138
5139 -def fl_winmove(win, dx, dy):
5140 """ 5141 fl_winmove(win, dx, dy) 5142 5143 Moves a window to a new position. 5144 5145 @param win : window to move to a new position 5146 @param dx : new horizontal position 5147 @param dy : new vertical position 5148 """ 5149 5150 _fl_winmove = cfuncproto( 5151 load_so_libforms(), "fl_winmove", \ 5152 None, [Window, FL_Coord, FL_Coord], \ 5153 """void fl_winmove(Window win, FL_Coord dx, FL_Coord dy) 5154 """) 5155 ulwin = convert_to_Window(win) 5156 idx = convert_to_int(dx) 5157 idy = convert_to_int(dy) 5158 keep_elem_refs(win, dx, dy, ulwin, idx, idy) 5159 _fl_winmove(ulwin, idx, idy)
5160 5161
5162 -def fl_winreshape(win, dx, dy, w, h):
5163 """ fl_winreshape(win, dx, dy, w, h) 5164 """ 5165 5166 _fl_winreshape = cfuncproto( 5167 load_so_libforms(), "fl_winreshape", \ 5168 None, [Window, FL_Coord, FL_Coord, FL_Coord, FL_Coord], \ 5169 """void fl_winreshape(Window win, FL_Coord dx, FL_Coord dy, 5170 FL_Coord w, FL_Coord h) 5171 """) 5172 ulwin = convert_to_Window(win) 5173 idx = convert_to_int(dx) 5174 idy = convert_to_int(dy) 5175 iw = convert_to_FL_Coord(w) 5176 ih = convert_to_FL_Coord(h) 5177 keep_elem_refs(win, dx, dy, w, h, ulwin, idx, idy, iw, ih) 5178 _fl_winreshape(ulwin, idx, idy, iw, ih)
5179 5180
5181 -def fl_winicon(win, icon, mask):
5182 """ 5183 fl_winicon(win, icon, mask) 5184 5185 Installs an icon for the window. 5186 5187 @param win : window 5188 @param icon : pixmap icon to be installed in window 5189 @param mask : mask 5190 """ 5191 5192 _fl_winicon = cfuncproto( 5193 load_so_libforms(), "fl_winicon", \ 5194 None, [Window, Pixmap, Pixmap], \ 5195 """void fl_winicon(Window win, Pixmap p, Pixmap m) 5196 """) 5197 ulwin = convert_to_Window(win) 5198 ulicon = convert_to_Pixmap(icon) 5199 ulmask = convert_to_Pixmap(mask) 5200 keep_elem_refs(win, icon, mask, ulwin, ulicon, ulmask) 5201 _fl_winicon(ulwin, ulicon, ulmask)
5202 5203
5204 -def fl_winbackground(win, bkcolr):
5205 """ 5206 fl_winbackground(win, bkcolr) 5207 5208 Sets the background of the window to a certain color. 5209 5210 @param win : window 5211 @param bkcolr : background color to be set 5212 """ 5213 5214 _fl_winbackground = cfuncproto( 5215 load_so_libforms(), "fl_winbackground", \ 5216 None, [Window, FL_COLOR], \ 5217 """void fl_winbackground(Window win, FL_COLOR bk) 5218 """) 5219 check_admitted_listvalues(bkcolr, COLOR_list) 5220 ulwin = convert_to_Window(win) 5221 ulbkcolr = convert_to_FL_COLOR(bkcolr) 5222 keep_elem_refs(win, bkcolr, ulwin, ulbkcolr) 5223 _fl_winbackground(ulwin, ulbkcolr)
5224 5225
5226 -def fl_winstepsize(win, dx, dy):
5227 """ fl_winstepsize(win, dx, dy) 5228 """ 5229 5230 _fl_winstepsize = cfuncproto( 5231 load_so_libforms(), "fl_winstepsize", \ 5232 None, [Window, FL_Coord, FL_Coord], \ 5233 """void fl_winstepsize(Window win, FL_Coord dx, FL_Coord dy) 5234 """) 5235 ulwin = convert_to_Window(win) 5236 idx = convert_to_int(dx) 5237 idy = convert_to_int(dy) 5238 keep_elem_refs(win, dx, dy, ulwin, idx, idy) 5239 _fl_winstepsize(ulwin, idx, idy)
5240 5241 5242 fl_winstepunit = fl_winstepsize 5243 fl_set_winstepunit = fl_winstepsize 5244 5245
5246 -def fl_winisvalid(win):
5247 """ 5248 fl_winisvalid(win) -> num. 5249 5250 Returns if a window is a valid one. 5251 5252 @param win : window to evaluate 5253 """ 5254 5255 _fl_winisvalid = cfuncproto( 5256 load_so_libforms(), "fl_winisvalid", \ 5257 cty.c_int, [Window], \ 5258 """int fl_winisvalid(Window win) 5259 """) 5260 ulwin = convert_to_Window(win) 5261 keep_elem_refs(win, ulwin) 5262 retval = _fl_winisvalid(ulwin) 5263 return retval
5264 5265
5266 -def fl_wintitle(win, title):
5267 """ 5268 fl_wintitle(win, title) 5269 5270 Changes the window title (and its associated icon title). 5271 5272 @param win : window 5273 @param title : window title to be set 5274 """ 5275 5276 _fl_wintitle = cfuncproto( 5277 load_so_libforms(), "fl_wintitle", \ 5278 None, [Window, STRING], \ 5279 """void fl_wintitle(Window win, const char * title) 5280 """) 5281 ulwin = convert_to_Window(win) 5282 stitle = convert_to_string(title) 5283 keep_elem_refs(win, title, ulwin, stitle) 5284 _fl_wintitle(ulwin, stitle)
5285 5286
5287 -def fl_winicontitle(win, title):
5288 """ 5289 fl_winicontitle(win, title) 5290 5291 Changes only the icon title for the window. 5292 5293 @param win : window 5294 @param title : icon title to be set 5295 """ 5296 5297 _fl_winicontitle = cfuncproto( 5298 load_so_libforms(), "fl_winicontitle", \ 5299 None, [Window, STRING], \ 5300 """void fl_winicontitle(Window win, const char * title) 5301 """) 5302 ulwin = convert_to_Window(win) 5303 stitle = convert_to_string(title) 5304 keep_elem_refs(win, title, ulwin, stitle) 5305 _fl_winicontitle(ulwin, stitle)
5306 5307
5308 -def fl_winposition(x, y):
5309 """ 5310 fl_winposition(x, y) 5311 5312 Sets the position of a window to be opened. 5313 5314 @param x : horizontal position of the window (upper-left corner) 5315 @param y : vertical position of the window (upper-left corner) 5316 """ 5317 5318 _fl_winposition = cfuncproto( 5319 load_so_libforms(), "fl_winposition", 5320 None, [FL_Coord, FL_Coord], 5321 """void fl_winposition(FL_Coord x, FL_Coord y) 5322 """) 5323 ix = convert_to_FL_Coord(x) 5324 iy = convert_to_FL_Coord(y) 5325 keep_elem_refs(x, y, ix, iy) 5326 _fl_winposition(ix, iy)
5327 5328 5329 fl_pref_winposition = fl_winposition 5330 fl_win_background = fl_winbackground 5331 fl_set_winstepunit = fl_winstepunit 5332 5333
5334 -def fl_winminsize(win, w, h):
5335 """ 5336 fl_winminsize(win, w, h) 5337 5338 Sets a constraint for a resizable window whose size will be within a 5339 range not less than minumum (to be used before calling fl_winopen). 5340 5341 @param win : window to be set 5342 @param w : minimum width of window 5343 @param h : minimum height of window 5344 """ 5345 5346 _fl_winminsize = cfuncproto( 5347 load_so_libforms(), "fl_winminsize", 5348 None, [Window, FL_Coord, FL_Coord], 5349 """void fl_winminsize(Window win, FL_Coord w, FL_Coord h) 5350 """) 5351 ulwin = convert_to_Window(win) 5352 iw = convert_to_FL_Coord(w) 5353 ih = convert_to_FL_Coord(h) 5354 keep_elem_refs(win, w, h, ulwin, iw, ih) 5355 _fl_winminsize(ulwin, iw, ih)
5356 5357
5358 -def fl_winmaxsize(win, w, h):
5359 """ 5360 fl_winmaxsize(win, w, h) 5361 5362 Sets a constraint for a resizable window whose size will be within a 5363 range not bigger than maximum (before calling fl_winopen). 5364 5365 @param win : window to be set 5366 @param w : maximum width of window 5367 @param h : maximum height of window 5368 """ 5369 5370 _fl_winmaxsize = cfuncproto( 5371 load_so_libforms(), "fl_winmaxsize", 5372 None, [Window, FL_Coord, FL_Coord], 5373 """void fl_winmaxsize(Window win, FL_Coord w, FL_Coord h) 5374 """) 5375 ulwin = convert_to_Window(win) 5376 iw = convert_to_FL_Coord(w) 5377 ih = convert_to_FL_Coord(h) 5378 keep_elem_refs(win, w, h, ulwin, iw, ih) 5379 _fl_winmaxsize(ulwin, iw, ih)
5380 5381
5382 -def fl_winaspect(win, x, y):
5383 """ 5384 fl_winaspect(win, x, y) 5385 5386 Sets the aspect ratio of the window for later interactive resizing. 5387 5388 @param win : window to be set 5389 @param x : horizontal aspect ratio 5390 @param y : vertical aspect ratio 5391 """ 5392 5393 _fl_winaspect = cfuncproto( 5394 load_so_libforms(), "fl_winaspect", 5395 None, [Window, FL_Coord, FL_Coord], 5396 """void fl_winaspect(Window win, FL_Coord x, FL_Coord y) 5397 """) 5398 ulwin = convert_to_Window(win) 5399 ix = convert_to_FL_Coord(x) 5400 iy = convert_to_FL_Coord(y) 5401 keep_elem_refs(win, x, y, ulwin, ix, iy) 5402 _fl_winaspect(ulwin, ix, iy)
5403 5404
5405 -def fl_reset_winconstraints(win):
5406 """ fl_reset_winconstraints(win) 5407 """ 5408 5409 _fl_reset_winconstraints = cfuncproto( 5410 load_so_libforms(), "fl_reset_winconstraints", 5411 None, [Window], 5412 """void fl_reset_winconstraints(Window win) 5413 """) 5414 ulwin = convert_to_Window(win) 5415 keep_elem_refs(win) 5416 _fl_reset_winconstraints(ulwin)
5417 5418
5419 -def fl_winsize(w, h):
5420 """ 5421 fl_winsize(w, h) 5422 5423 Sets the preferred window size (before calling fl_winopen), and makes 5424 the window non-resizeable. 5425 5426 @param w : width of the window in pixels 5427 @param h : height of the window in pixels 5428 """ 5429 5430 _fl_winsize = cfuncproto( 5431 load_so_libforms(), "fl_winsize", 5432 None, [FL_Coord, FL_Coord], 5433 """void fl_winsize(FL_Coord w, FL_Coord h) 5434 """) 5435 iw = convert_to_FL_Coord(w) 5436 ih = convert_to_FL_Coord(h) 5437 keep_elem_refs(w, h, iw, ih) 5438 _fl_winsize(iw, ih)
5439 5440
5441 -def fl_initial_winsize(w, h):
5442 """ 5443 fl_initial_winsize(w, h) 5444 5445 Sets the preferred window size (before calling fl_winopen). 5446 5447 @param w : width of the window in pixels 5448 @param h : height of the window in pixels 5449 """ 5450 5451 _fl_initial_winsize = cfuncproto( 5452 load_so_libforms(), "fl_initial_winsize", 5453 None, [FL_Coord, FL_Coord], 5454 """void fl_initial_winsize(FL_Coord w, FL_Coord h) 5455 """) 5456 iw = convert_to_FL_Coord(w) 5457 ih = convert_to_FL_Coord(h) 5458 keep_elem_refs(w, h, iw, ih) 5459 _fl_initial_winsize(iw, ih)
5460 5461 5462 fl_pref_winsize = fl_winsize 5463 5464
5465 -def fl_initial_winstate(state):
5466 """ fl_initial_winstate(state) 5467 """ 5468 5469 _fl_initial_winstate = cfuncproto( 5470 load_so_libforms(), "fl_initial_winstate", 5471 None, [cty.c_int], 5472 """void fl_initial_winstate(int state) 5473 """) 5474 istate = convert_to_int(state) 5475 keep_elem_refs(state, istate) 5476 _fl_initial_winstate(istate)
5477 5478
5479 -def fl_create_colormap(pXVisualInfo, nfill):
5480 """ fl_create_colormap(pXVisualInfo, nfill) -> colormap 5481 """ 5482 5483 _fl_create_colormap = cfuncproto( 5484 load_so_libforms(), "fl_create_colormap", 5485 Colormap, [cty.POINTER(XVisualInfo), cty.c_int], 5486 """)Colormap fl_create_colormap(XVisualInfo * xv, int nfill) 5487 """) 5488 infill = convert_to_int(nfill) 5489 keep_elem_refs(pXVisualInfo, nfill, infill) 5490 retval = _fl_create_colormap(pXVisualInfo, infill) 5491 return retval
5492 5493
5494 -def fl_wingeometry(x, y, w, h):
5495 """ 5496 fl_wingeometry(x, y, w, h) 5497 5498 Sets the initial geometry (position and size) of the window to be 5499 opened; the window will not be resizable. 5500 5501 @param x : horizontal position of the window (upper-left corner) 5502 @param y : vertical position of the window (upper-left corner) 5503 @param w : width of the window in pixels 5504 @param h : height of the window in pixels 5505 """ 5506 5507 _fl_wingeometry = cfuncproto( 5508 load_so_libforms(), "fl_wingeometry", 5509 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 5510 """void fl_wingeometry(FL_Coord x, FL_Coord y, FL_Coord w, 5511 FL_Coord h) 5512 """) 5513 ix = convert_to_FL_Coord(x) 5514 iy = convert_to_FL_Coord(y) 5515 iw = convert_to_FL_Coord(w) 5516 ih = convert_to_FL_Coord(h) 5517 keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 5518 _fl_wingeometry(ix, iy, iw, ih)
5519 5520 5521 fl_pref_wingeometry = fl_wingeometry 5522 5523
5524 -def fl_initial_wingeometry(x, y, w, h):
5525 """ 5526 fl_initial_wingeometry(x, y, w, h) 5527 5528 Sets the initial geometry (position and size) of the window to be 5529 opened. 5530 5531 @param x : horizontal position of the window (upper-left corner) 5532 @param y : vertical position of the window (upper-left corner) 5533 @param w : width of the window in pixels 5534 @param h : height of the window in pixels 5535 """ 5536 5537 _fl_initial_wingeometry = cfuncproto( 5538 load_so_libforms(), "fl_initial_wingeometry", 5539 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 5540 """void fl_initial_wingeometry(FL_Coord x, FL_Coord y, 5541 FL_Coord w, FL_Coord h) 5542 """) 5543 ix = convert_to_FL_Coord(x) 5544 iy = convert_to_FL_Coord(y) 5545 iw = convert_to_FL_Coord(w) 5546 ih = convert_to_FL_Coord(h) 5547 keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 5548 _fl_initial_wingeometry(ix, iy, iw, ih)
5549 5550
5551 -def fl_noborder():
5552 """ 5553 fl_noborder() 5554 5555 Suppresses the window manager's decoration (before creating the 5556 window). 5557 """ 5558 5559 _fl_noborder = cfuncproto( 5560 load_so_libforms(), "fl_noborder", 5561 None, [], 5562 """void fl_noborder() 5563 """) 5564 _fl_noborder()
5565 5566
5567 -def fl_transient():
5568 """ 5569 fl_transient() 5570 5571 Makes a window a transient one (before creating the window). 5572 """ 5573 5574 _fl_transient = cfuncproto( 5575 load_so_libforms(), "fl_transient", 5576 None, [], \ 5577 """void fl_transient() 5578 """) 5579 _fl_transient()
5580 5581 5582 #def fl_get_winsize(win, w, h) *API change*
5583 -def fl_get_winsize(win):
5584 """ fl_get_winsize(win) -> width, height 5585 5586 @param win : window 5587 """ 5588 5589 _fl_get_winsize = cfuncproto( 5590 load_so_libforms(), "fl_get_winsize", 5591 None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 5592 """void fl_get_winsize(Window win, FL_Coord * w, FL_Coord * h) 5593 """) 5594 ulwin = convert_to_Window(win) 5595 iw, pw = make_int_and_pointer() 5596 ih, ph = make_int_and_pointer() 5597 keep_elem_refs(win, ulwin, iw, ih, pw, ph) 5598 _fl_get_winsize(ulwin, pw, ph) 5599 return iw, ih
5600 5601 5602 #def fl_get_winorigin(win, x, y) *API change*
5603 -def fl_get_winorigin(win):
5604 """ fl_get_winorigin(win) -> x, y 5605 """ 5606 5607 _fl_get_winorigin = cfuncproto( 5608 load_so_libforms(), "fl_get_winorigin", 5609 None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 5610 """void fl_get_winorigin(Window win, FL_Coord * x, FL_Coord * y) 5611 """) 5612 ulwin = convert_to_Window(win) 5613 x, px = make_FL_Coord_and_pointer() 5614 y, py = make_FL_Coord_and_pointer() 5615 keep_elem_refs(win, ulwin, x, y, px, py) 5616 _fl_get_winorigin(win, px, py) 5617 return x, y
5618 5619 5620 #def fl_get_wingeometry(win, x, y, w, h) *API change*
5621 -def fl_get_wingeometry(win):
5622 """ 5623 fl_get_wingeometry(win) -> x, y, w, h 5624 5625 Returns geometry (position and size) of a window. 5626 5627 @param win : window 5628 """ 5629 5630 _fl_get_wingeometry = cfuncproto( 5631 load_so_libforms(), "fl_get_wingeometry", 5632 None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 5633 cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 5634 """void fl_get_wingeometry(Window win, FL_Coord * x, FL_Coord * y, 5635 FL_Coord * w, FL_Coord * h) 5636 """) 5637 ulwin = convert_to_Window(win) 5638 x, px = make_FL_Coord_and_pointer() 5639 y, py = make_FL_Coord_and_pointer() 5640 w, pw = make_FL_Coord_and_pointer() 5641 h, ph = make_FL_Coord_and_pointer() 5642 keep_elem_refs(win, x, y, w, h, ulwin, px, py, pw, ph) 5643 _fl_get_wingeometry(ulwin, px, py, pw, ph) 5644 return x, y, w, h
5645 5646 5647 # For compatibility 5648 fl_get_win_size = fl_get_winsize 5649 fl_get_win_origin = fl_get_winorigin 5650 fl_get_win_geometry = fl_get_wingeometry 5651 fl_initial_winposition = fl_pref_winposition 5652 5653
5654 -def fl_get_display(): # NOT SURE
5655 return fl_display 5656 5657
5658 -def FL_FormDisplay(pForm): # NOT SURE
5659 return fl_display 5660 5661
5662 -def FL_ObjectDisplay(object): # NOT SURE
5663 return fl_display 5664 5665
5666 -def FL_IS_CANVAS(pObject):
5667 if (pObject.contents.objclass == FL_CANVAS) or \ 5668 (pObject.contents.objclass == FL_GLCANVAS): 5669 return True 5670 else: 5671 return False
5672 5673 5674 # The window an object belongs to - for drawing
5675 -def FL_ObjWin(pObject):
5676 if FL_IS_CANVAS(pObject): 5677 return fl_get_canvas_id(pObject) 5678 else: 5679 return pObject.contents.form.contents.window
5680 5681
5682 -def fl_get_real_object_window(pObject):
5683 """ fl_get_real_object_window(pObject) -> window 5684 5685 @param pObject : pointer to object 5686 """ 5687 5688 _fl_get_real_object_window = cfuncproto( 5689 load_so_libforms(), "fl_get_real_object_window", 5690 Window, [cty.POINTER(FL_OBJECT)], 5691 """Window fl_get_real_object_window(FL_OBJECT * ob) 5692 """) 5693 keep_elem_refs(pObject) 5694 retval = _fl_get_real_object_window(pObject) 5695 return retval
5696 5697 5698 FL_OBJECT_WID = FL_ObjWin 5699 5700 5701 # Replacements for X functions that access the event queue 5702
5703 -def fl_XNextEvent(pXEvent):
5704 """ fl_XNextEvent(pXEvent) -> event num. 5705 """ 5706 5707 _fl_XNextEvent = cfuncproto( 5708 load_so_libforms(), "fl_XNextEvent", 5709 cty.c_int, [cty.POINTER(XEvent)], 5710 """int fl_XNextEvent(XEvent * xev) 5711 """) 5712 keep_elem_refs(pXEvent) 5713 retval = _fl_XNextEvent(pXEvent) 5714 return retval
5715 5716
5717 -def fl_XPeekEvent(pXEvent):
5718 """ fl_XPeekEvent(pXEvent) -> event num. 5719 """ 5720 5721 _fl_XPeekEvent = cfuncproto( 5722 load_so_libforms(), "fl_XPeekEvent", 5723 cty.c_int, [cty.POINTER(XEvent)], 5724 """int fl_XPeekEvent(XEvent * xev) 5725 """) 5726 keep_elem_refs(pXEvent) 5727 retval = _fl_XPeekEvent(pXEvent) 5728 return retval
5729 5730
5731 -def fl_XEventsQueued(mode):
5732 """ fl_XEventsQueued(mode) -> event num. 5733 """ 5734 5735 _fl_XEventsQueued = cfuncproto( 5736 load_so_libforms(), "fl_XEventsQueued", 5737 cty.c_int, [cty.c_int], 5738 """int fl_XEventsQueued(int mode) 5739 """) 5740 imode = convert_to_int(mode) 5741 keep_elem_refs(mode, imode) 5742 retval = _fl_XEventsQueued(imode) 5743 return retval
5744 5745
5746 -def fl_XPutBackEvent(pXEvent):
5747 """ fl_XPutBackEvent(pXEvent) 5748 """ 5749 5750 _fl_XPutBackEvent = cfuncproto( 5751 load_so_libforms(), "fl_XPutBackEvent", 5752 None, [cty.POINTER(XEvent)], 5753 """void fl_XPutBackEvent(XEvent * xev) 5754 """) 5755 keep_elem_refs(pXEvent) 5756 _fl_XPutBackEvent(pXEvent)
5757 5758
5759 -def fl_last_event():
5760 """ fl_last_event() -> event 5761 """ 5762 5763 _fl_last_event = cfuncproto( 5764 load_so_libforms(), "fl_last_event", 5765 cty.POINTER(XEvent), [], 5766 """const char * fl_last_event() 5767 """) 5768 retval = _fl_last_event() 5769 return retval
5770 5771 5772 FL_APPEVENT_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(XEvent), cty.c_void_p) 5773
5774 -def fl_set_event_callback(py_AppEventCb, userdata):
5775 """ 5776 fl_set_event_callback(py_AppEventCb, userdata) -> event callback 5777 """ 5778 5779 _fl_set_event_callback = cfuncproto( 5780 load_so_libforms(), "fl_set_event_callback", 5781 FL_APPEVENT_CB, [FL_APPEVENT_CB, cty.c_void_p], 5782 """FL_APPEVENT_CB fl_set_event_callback(FL_APPEVENT_CB callback, 5783 void * user_data) 5784 """) 5785 c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 5786 puserdata = cty.cast(userdata, cty.c_void_p) 5787 keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 5788 keep_elem_refs(userdata, puserdata) 5789 retval = _fl_set_event_callback(c_AppEventCb, puserdata) 5790 return retval
5791 5792
5793 -def fl_set_idle_callback(py_AppEventCb, userdata):
5794 """ fl_set_idle_callback(py_AppEventCb, userdata) -> event callback func. 5795 """ 5796 5797 _fl_set_idle_callback = cfuncproto( 5798 load_so_libforms(), "fl_set_idle_callback", 5799 FL_APPEVENT_CB, [FL_APPEVENT_CB, cty.c_void_p], 5800 """FL_APPEVENT_CB fl_set_idle_callback(FL_APPEVENT_CB callback, 5801 void * user_data) 5802 """) 5803 c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 5804 puserdata = cty.cast(userdata, cty.c_void_p) 5805 keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 5806 keep_elem_refs(userdata, puserdata) 5807 retval = _fl_set_idle_callback(c_AppEventCb, puserdata) 5808 return retval
5809 5810
5811 -def fl_addto_selected_xevent(win, mask):
5812 """ fl_addto_selected_xevent(win, mask) -> num. 5813 """ 5814 5815 _fl_addto_selected_xevent = cfuncproto( 5816 load_so_libforms(), "fl_addto_selected_xevent", 5817 cty.c_long, [Window, cty.c_long], 5818 """long int fl_addto_selected_xevent(Window win, long int mask) 5819 """) 5820 ulwin = convert_to_Window(win) 5821 lmask = convert_to_long(mask) 5822 keep_elem_refs(win, mask, ulwin, lmask) 5823 retval = _fl_addto_selected_xevent(ulwin, lmask) 5824 return retval
5825 5826
5827 -def fl_remove_selected_xevent(win, mask):
5828 """ fl_remove_selected_xevent(win, mask) -> num. 5829 """ 5830 5831 _fl_remove_selected_xevent = cfuncproto( 5832 load_so_libforms(), "fl_remove_selected_xevent", 5833 cty.c_long, [Window, cty.c_long], 5834 """)long int fl_remove_selected_xevent(Window win, long int mask) 5835 """) 5836 ulwin = convert_to_Window(win) 5837 lmask = convert_to_long(mask) 5838 keep_elem_refs(win, mask, ulwin, lmask) 5839 retval = _fl_remove_selected_xevent(ulwin, lmask) 5840 return retval
5841 5842 5843 fl_add_selected_xevent = fl_addto_selected_xevent 5844 5845
5846 -def fl_set_idle_delta(delta):
5847 """ fl_set_idle_delta(delta) 5848 """ 5849 5850 _fl_set_idle_delta = cfuncproto( 5851 load_so_libforms(), "fl_set_idle_delta", 5852 None, [cty.c_long], 5853 """void fl_set_idle_delta(long int delta) 5854 """) 5855 ldelta = convert_to_long(delta) 5856 keep_elem_refs(delta, ldelta) 5857 _fl_set_idle_delta(ldelta)
5858 5859
5860 -def fl_add_event_callback(win, ev, py_AppEventCb, userdata):
5861 """ 5862 fl_add_event_callback(win, ev, py_AppEventCb, userdata) -> event callback 5863 5864 Adds an event handler for a window. 5865 5866 @param win : window id to add event handler to 5867 @param ev : event number 5868 @param py_AppEventCb : python function for handling event, fn(pXevent, 5869 ptr_void) -> num 5870 @param userdata : user data argument 5871 """ 5872 5873 _fl_add_event_callback = cfuncproto( 5874 load_so_libforms(), "fl_add_event_callback", 5875 FL_APPEVENT_CB, [Window, cty.c_int, FL_APPEVENT_CB, cty.c_void_p], 5876 """FL_APPEVENT_CB fl_add_event_callback(Window win, int ev, 5877 FL_APPEVENT_CB wincb, void * user_data) 5878 """) 5879 ulwin = convert_to_Window(win) 5880 iev = convert_to_int(ev) 5881 c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 5882 puserdata = cty.cast(userdata, cty.c_void_p) 5883 keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 5884 keep_elem_refs(win, ev, userdata, ulwin, iev, puserdata) 5885 retval = _fl_add_event_callback(ulwin, iev, c_AppEventCb, puserdata) 5886 return retval
5887 5888
5889 -def fl_remove_event_callback(win, ev):
5890 """ 5891 fl_remove_event_callback(win, ev) 5892 5893 Removes one or all event callbacks for a window. May be called 5894 with for a window for which no event callbacks have been set. 5895 5896 @param win : window id 5897 @param ev : evnet number 5898 """ 5899 5900 _fl_remove_event_callback = cfuncproto( 5901 load_so_libforms(), "fl_remove_event_callback", 5902 None, [Window, cty.c_int], 5903 """void fl_remove_event_callback(Window win, int ev) 5904 """) 5905 ulwin = convert_to_Window(win) 5906 iev = convert_to_int(ev) 5907 keep_elem_refs(win, ev, ulwin, iev) 5908 _fl_remove_event_callback(ulwin, iev)
5909 5910
5911 -def fl_activate_event_callbacks(win):
5912 """ fl_activate_event_callbacks(win) 5913 5914 @param win : window whose events are referred to 5915 """ 5916 5917 _fl_activate_event_callbacks = cfuncproto( 5918 load_so_libforms(), "fl_activate_event_callbacks", 5919 None, [Window], 5920 """void fl_activate_event_callbacks(Window win) 5921 """) 5922 ulwin = convert_to_Window(win) 5923 keep_elem_refs(win, ulwin) 5924 _fl_activate_event_callbacks(ulwin)
5925 5926
5927 -def fl_print_xevent_name(where, pXEvent):
5928 """ fl_print_xevent_name(where, pXEvent) -> pXEvent 5929 """ 5930 5931 _fl_print_xevent_name = cfuncproto( 5932 load_so_libforms(), "fl_print_xevent_name", 5933 cty.POINTER(XEvent), [STRING, cty.POINTER(XEvent)], 5934 """XEvent * fl_print_xevent_name(const char * where, 5935 const Xevent * xev) 5936 """) 5937 swhere = convert_to_string(where) 5938 keep_elem_refs(where, pXEvent, swhere) 5939 retval = _fl_print_xevent_name(swhere, pXEvent) 5940 return retval
5941 5942
5943 -def fl_XFlush():
5944 """ 5945 fl_XFlush() 5946 5947 Convenience replacement for XFlush() 5948 """ 5949 5950 _fl_XFlush = cfuncproto( 5951 load_so_libforms(), "fl_XFlush", 5952 None, [], 5953 """void fl_XFlush(void) 5954 """) 5955 _fl_XFlush()
5956 5957
5958 -def metakey_down(mask):
5959 return (mask & Mod1Mask)
5960 5961
5962 -def shiftkey_down(mask):
5963 return (mask & ShiftMask)
5964 5965
5966 -def controlkey_down(mask):
5967 return (mask & ControlMask)
5968 5969
5970 -def button_down(mask):
5971 if (mask & Button1Mask) or (mask & Button2Mask) or \ 5972 (mask & Button3Mask) or (mask & Button4Mask) or \ 5973 (mask & Button5Mask): 5974 return True 5975 else: 5976 return False
5977 5978 5979 # Resources 5980
5981 -def fl_initialize(lsysargv, sysargv, appclass, appopt, nappopt):
5982 """ fl_initialize(numargs, args, applclass, apploptions, numapplopts) -> pDisplay 5983 """ 5984 5985 _fl_initialize = cfuncproto( 5986 load_so_libforms(), "fl_initialize", 5987 cty.POINTER(Display), [cty.POINTER(cty.c_int), 5988 cty.POINTER(STRING), STRING, cty.POINTER(XrmOptionDescRec), 5989 cty.c_int], 5990 """Display * fl_initialize(int * na, char * * arg, 5991 const char * appclass, FL_CMD_OPT * appopt, int nappopt) 5992 """) 5993 verify_version_compatibility() # verify if installed XForms 5994 # is compatible with this one 5995 lsysargv = 1 5996 cliargs_nr = cty.c_int(lsysargv) #1 5997 cliargs_nr_p = cty.byref(cliargs_nr) 5998 argum = "".join(sysargv) 5999 scliargs = convert_to_string(argum) # " " 6000 sappclass = convert_to_string(appclass) 6001 structopts = cty.POINTER(FL_CMD_OPT)() 6002 keep_elem_refs(cliargs_nr_p, scliargs, appclass, sappclass, structopts, 6003 nappopt) 6004 retval = _fl_initialize(cliargs_nr_p, scliargs, sappclass, structopts, 6005 nappopt) 6006 return retval
6007 6008
6009 -def fl_finish():
6010 """ fl_finish() 6011 """ 6012 6013 _fl_finish = cfuncproto( 6014 load_so_libforms(), "fl_finish", 6015 None, [], 6016 """void fl_finish() 6017 """) 6018 _fl_finish()
6019 6020
6021 -def fl_get_resource(rname, cname, dtype, defval, val, size):
6022 """ fl_get_resource(rname, cname, dtype, defval, val, size) -> string 6023 """ 6024 6025 _fl_get_resource = cfuncproto( 6026 load_so_libforms(), "fl_get_resource", 6027 STRING, [STRING, STRING, FL_RTYPE, STRING, cty.c_void_p, 6028 cty.c_int], 6029 """const char * fl_get_resource(const char * rname, 6030 const char * cname, FL_RTYPE dtype, const char * defval, 6031 void * val, int size) 6032 """) 6033 srname = convert_to_string(rname) 6034 scname = convert_to_string(cname) 6035 idtype = convert_to_int(dtype) 6036 sdefval = convert_to_string(defval) 6037 pval = cty.cast(val, cty.c_void_p) 6038 isize = convert_to_int(size) 6039 keep_elem_refs(rname, cname, dtype, defval, val, size, srname, scname, 6040 idtype, sdefval, pval, isize) 6041 retval = _fl_get_resource(srname, scname, idtype, sdefval, pval, isize) 6042 return retval
6043 6044
6045 -def fl_set_resource(resstr, val):
6046 """ fl_set_resource(resstr, val) 6047 6048 @param resstr : resource name 6049 @param val : new string value for resource 6050 """ 6051 6052 _fl_set_resource = cfuncproto( 6053 load_so_libforms(), "fl_set_resource", 6054 None, [STRING, STRING], 6055 """void fl_set_resource(const char * str, const char * val) 6056 """) 6057 sresstr = convert_to_string(resstr) 6058 sval = convert_to_string(val) 6059 keep_elem_refs(resstr, val, sresstr, sval) 6060 _fl_set_resource(sresstr, sval)
6061 6062
6063 -def fl_get_app_resources(pResource, n):
6064 """ fl_get_app_resources(pResource, n) 6065 """ 6066 6067 _fl_get_app_resources = cfuncproto( 6068 load_so_libforms(), "fl_get_app_resources", 6069 None, [cty.POINTER(FL_RESOURCE), cty.c_int], 6070 """void fl_get_app_resources(FL_RESOURCE * appresource, int n) 6071 """) 6072 inum = convert_to_int(n) 6073 keep_elem_refs(pResource, n, inum) 6074 _fl_get_app_resources(pResource, inum)
6075 6076
6077 -def fl_set_graphics_mode(mode, doublebuf):
6078 """ fl_set_graphics_mode(mode, doublebuf) 6079 """ 6080 6081 _fl_set_graphics_mode = cfuncproto( 6082 load_so_libforms(), "fl_set_graphics_mode", 6083 None, [cty.c_int, cty.c_int], 6084 """void fl_set_graphics_mode(int mode, int doublebuf) 6085 """) 6086 imode = convert_to_int(mode) 6087 idoublebuf = convert_to_int(doublebuf) 6088 keep_elem_refs(mode, doublebuf, imode, idoublebuf) 6089 _fl_set_graphics_mode(imode, idoublebuf)
6090 6091
6092 -def fl_set_visualID(idnum):
6093 """ fl_set_visualID(idnum) 6094 """ 6095 6096 _fl_set_visualID = cfuncproto( 6097 load_so_libforms(), "fl_set_visualID", 6098 None, [cty.c_long], 6099 """void fl_set_visualID(long int id) 6100 """) 6101 lidnum = convert_to_long(idnum) 6102 keep_elem_refs(idnum, lidnum) 6103 _fl_set_visualID(lidnum)
6104 6105
6106 -def fl_keysym_pressed(keysym):
6107 """ fl_keysym_pressed(keysym) -> num. 6108 """ 6109 6110 _fl_keysym_pressed = cfuncproto( 6111 load_so_libforms(), "fl_keysym_pressed", 6112 cty.c_int, [KeySym], 6113 """int fl_keysym_pressed(KeySym k) 6114 """) 6115 ulkeysym = convert_to_ulong(keysym) 6116 keep_elem_refs(keysym, ulkeysym) 6117 retval = _fl_keysym_pressed(ulkeysym) 6118 return retval
6119 6120 6121 fl_keypressed = fl_keysym_pressed 6122 6123 6124 # Program default masks 6125
6126 -def fl_set_defaults(mask, pIopt):
6127 """ fl_set_defaults(mask, pIopt) 6128 """ 6129 6130 _fl_set_defaults = cfuncproto( 6131 load_so_libforms(), "fl_set_defaults", 6132 None, [cty.c_ulong, cty.POINTER(FL_IOPT)], 6133 """void fl_set_defaults(long unsigned int mask, FL_IOPT * cntl): 6134 """) 6135 ulmask = convert_to_ulong(mask) 6136 keep_elem_refs(mask, pIopt, ulmask) 6137 _fl_set_defaults(ulmask, pIopt)
6138 6139
6140 -def fl_set_tabstop(s):
6141 """ fl_set_tabstop(s) 6142 """ 6143 6144 _fl_set_tabstop = cfuncproto( 6145 load_so_libforms(), "fl_set_tabstop", 6146 None, [STRING], 6147 """void fl_set_tabstop(const char * s) 6148 """) 6149 ss = convert_to_string(s) 6150 keep_elem_refs(s, ss) 6151 _fl_set_tabstop(ss)
6152 6153
6154 -def fl_get_defaults(pIopt):
6155 """ fl_get_defaults(pIopt) 6156 """ 6157 6158 _fl_get_defaults = cfuncproto( 6159 load_so_libforms(), "fl_get_defaults", 6160 None, [cty.POINTER(FL_IOPT)], 6161 """void fl_get_defaults(FL_IOPT * cntl) 6162 """) 6163 keep_elem_refs(pIopt) 6164 _fl_get_defaults(pIopt)
6165 6166
6167 -def fl_get_visual_depth():
6168 """ fl_get_visual_depth() -> depth num. 6169 """ 6170 6171 _fl_get_visual_depth = cfuncproto( 6172 load_so_libforms(), "fl_get_visual_depth", 6173 cty.c_int, [], 6174 """int fl_get_visual_depth() 6175 """) 6176 retval = _fl_get_visual_depth() 6177 return retval
6178 6179
6180 -def fl_vclass_name(n):
6181 """ fl_vclass_name(n) -> name string 6182 """ 6183 6184 _fl_vclass_name = cfuncproto( 6185 load_so_libforms(), "fl_vclass_name", 6186 STRING, [cty.c_int], 6187 """const char * fl_vclass_name(int n) 6188 """) 6189 inum = convert_to_int(n) 6190 keep_elem_refs(n, inum) 6191 _fl_vclass_name(inum)
6192 6193
6194 -def fl_vclass_val(val):
6195 """ fl_vclass_val(val) -> num. 6196 """ 6197 6198 _fl_vclass_val = cfuncproto( 6199 load_so_libforms(), "fl_vclass_val", 6200 cty.c_int, [STRING], 6201 """int fl_vclass_val(const char * v) 6202 """) 6203 sval = convert_to_string(val) 6204 keep_elem_refs(val, sval) 6205 retval = _fl_vclass_val(sval) 6206 return retval
6207 6208
6209 -def fl_set_ul_property(prop, thickness):
6210 """ fl_set_ul_property(prop, thickness) 6211 """ 6212 6213 _fl_set_ul_property = cfuncproto( 6214 load_so_libforms(), "fl_set_ul_property", 6215 None, [cty.c_int, cty.c_int], 6216 """void fl_set_ul_property(int prop, int thickness) 6217 """) 6218 iprop = convert_to_int(prop) 6219 ithickness = convert_to_int(thickness) 6220 keep_elem_refs(prop, thickness, iprop, ithickness) 6221 _fl_set_ul_property(iprop, ithickness)
6222 6223
6224 -def fl_set_clipping(x, y, w, h):
6225 """ fl_set_clipping(x, y, w, h) 6226 """ 6227 6228 _fl_set_clipping = cfuncproto( 6229 load_so_libforms(), "fl_set_clipping", 6230 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 6231 """void fl_set_clipping(FL_Coord x, FL_Coord y, FL_Coord w, 6232 FL_Coord h) 6233 """) 6234 ix = convert_to_FL_Coord(x) 6235 iy = convert_to_FL_Coord(y) 6236 iw = convert_to_FL_Coord(w) 6237 ih = convert_to_FL_Coord(h) 6238 keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 6239 _fl_set_clipping(ix, iy, iw, ih)
6240 6241
6242 -def fl_set_gc_clipping(gc, x, y, w, h):
6243 """ fl_set_gc_clipping(gc, x, y, w, h) 6244 """ 6245 6246 _fl_set_gc_clipping = cfuncproto( 6247 load_so_libforms(), "fl_set_gc_clipping", 6248 None, [GC, FL_Coord, FL_Coord, FL_Coord, FL_Coord], 6249 """void fl_set_gc_clipping(GC gc, FL_Coord x, FL_Coord y, 6250 FL_Coord w, FL_Coord h) 6251 """) 6252 ix = convert_to_FL_Coord(x) 6253 iy = convert_to_FL_Coord(y) 6254 iw = convert_to_FL_Coord(w) 6255 ih = convert_to_FL_Coord(h) 6256 keep_elem_refs(gc, x, y, w, h, ix, iy, iw, ih) 6257 _fl_set_gc_clipping(gc, ix, iy, iw, ih)
6258 6259
6260 -def fl_unset_gc_clipping(gc):
6261 """ fl_unset_gc_clipping(gc) 6262 """ 6263 6264 _fl_unset_gc_clipping = cfuncproto( 6265 load_so_libforms(), "fl_unset_gc_clipping", 6266 None, [GC], 6267 """void fl_unset_gc_clipping(GC gc) 6268 """) 6269 keep_elem_refs(gc) 6270 _fl_unset_gc_clipping(gc)
6271 6272
6273 -def fl_set_clippings(pRect, n):
6274 """ fl_set_clippings(pRect, n) 6275 """ 6276 6277 _fl_set_clippings = cfuncproto( 6278 load_so_libforms(), "fl_set_clippings", 6279 None, [cty.POINTER(FL_RECT), cty.c_int], 6280 """void fl_set_clippings(FL_RECT * xrect, int n) 6281 """) 6282 inum = convert_to_int(n) 6283 keep_elem_refs(pRect, n, inum) 6284 _fl_set_clippings(pRect, inum)
6285 6286
6287 -def fl_unset_clipping():
6288 """ fl_unset_clipping() 6289 """ 6290 6291 _fl_unset_clipping = cfuncproto( 6292 load_so_libforms(), "fl_unset_clipping", 6293 None, [], 6294 """void fl_unset_clipping() 6295 """) 6296 _fl_unset_clipping()
6297 6298
6299 -def fl_set_text_clipping(x, y, w, h):
6300 """ fl_set_text_clipping(x, y, w, h) 6301 """ 6302 6303 _fl_set_text_clipping = cfuncproto( 6304 load_so_libforms(), "fl_set_text_clipping", 6305 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 6306 """void fl_set_text_clipping(FL_Coord x, FL_Coord y, FL_Coord w, 6307 FL_Coord h) 6308 """) 6309 ix = convert_to_FL_Coord(x) 6310 iy = convert_to_FL_Coord(y) 6311 iw = convert_to_FL_Coord(w) 6312 ih = convert_to_FL_Coord(h) 6313 keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 6314 _fl_set_text_clipping(ix, iy, iw, ih)
6315 6316
6317 -def fl_unset_text_clipping():
6318 """ fl_unset_text_clipping() 6319 """ 6320 6321 _fl_unset_text_clipping = cfuncproto( 6322 load_so_libforms(), "fl_unset_text_clipping", 6323 None, [], 6324 """void fl_unset_text_clipping() 6325 """) 6326 _fl_unset_text_clipping()
6327 6328 6329 # How we pack and unpack colors 6330
6331 -def FL_PCCLAMP(a):
6332 if (a > FL_PCMAX): 6333 return FL_PCMAX 6334 elif (a < 0): 6335 return 0 6336 else: 6337 return a
6338 6339 6340 # If PCBITS is not 8, we need to apply the RGBmask 6341
6342 -def FL_GETR(packed):
6343 return ((packed >> FL_RSHIFT) & FL_RMASK)
6344 6345 # maybe unused in python?
6346 -def FL_GETG(packed):
6347 return ((packed) >> FL_GSHIFT) & FL_PCMAX
6348 6349 # maybe unused in python?
6350 -def FL_GETB(packed):
6351 return ((packed) >> FL_BSHIFT) & FL_PCMAX
6352 6353 # maybe unused in python?
6354 -def FL_GETA(packed):
6355 return ((packed) >> FL_ASHIFT) & FL_PCMAX
6356 6357 # maybe unused in python?
6358 -def FL_PACK3(r, g, b ):
6359 return (r<<FL_RSHIFT) | (g<<FL_GSHIFT) | (b<<FL_BSHIFT)
6360 6361 # maybe unused in python? 6362 FL_PACK = FL_PACK3 6363 6364 # maybe unused in python?
6365 -def FL_PACK4(r, g, b, a):
6366 return (FL_PACK3(r, g, b) | (a<<FL_ASHIFT))
6367 6368 # maybe unused in python?
6369 -def FL_UNPACK(p, r, g, b):
6370 r = FL_GETR(p) 6371 g = FL_GETG(p) 6372 b = FL_GETB(p) 6373 return r, g, b
6374 6375 # maybe unused in python? 6376 FL_UNPACK3 = FL_UNPACK 6377 6378 # maybe unused in python?
6379 -def FL_UNPACK4(p, r, g, b, a):
6380 r, g, b = FL_UNPACK3(p, r, g, b) 6381 a = FL_GETA(p) 6382 return r, g, b, a
6383 6384
6385 -def fl_popup_add(win, text):
6386 """ fl_popup_add(win, text) -> pPopup 6387 """ 6388 6389 _fl_popup_add = cfuncproto( 6390 load_so_libforms(), "fl_popup_add", 6391 cty.POINTER(FL_POPUP), [Window, STRING], 6392 """FL_POPUP * fl_popup_add(Window p1, const char * p2) 6393 """) 6394 ulwin = convert_to_Window(win) 6395 stext = convert_to_string(text) 6396 keep_elem_refs(win, text, ulwin, stext) 6397 retval = _fl_popup_add(ulwin, stext) 6398 return retval
6399 6400
6401 -def fl_popup_add_entries(pPopup, entrytxt):
6402 """ fl_popup_add_entries(pPopup, entrytxt) -> pPopupEntry 6403 """ 6404 6405 _fl_popup_add_entries = cfuncproto( 6406 load_so_libforms(), "fl_popup_add_entries", 6407 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 6408 """FL_POPUP_ENTRY * fl_popup_add_entries(FL_POPUP * p1, 6409 const char * p2) 6410 """) 6411 sentrytxt = convert_to_string(entrytxt) 6412 keep_elem_refs(pPopup, entrytxt, sentrytxt) 6413 retval = _fl_popup_add_entries(pPopup, sentrytxt) 6414 return retval
6415 6416
6417 -def fl_popup_insert_entries(pPopup, pPopupEntry, entrytxt):
6418 """ fl_popup_insert_entries(pPopup, pPopupEntry, entrytxt) -> pPopupEntry 6419 """ 6420 6421 _fl_popup_insert_entries = cfuncproto( 6422 load_so_libforms(), "fl_popup_insert_entries", 6423 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), 6424 cty.POINTER(FL_POPUP_ENTRY), STRING], 6425 """FL_POPUP_ENTRY * fl_popup_insert_entries(FL_POPUP * p1, 6426 FL_POPUP_ENTRY * p2, const char * p3) 6427 """) 6428 sentrytxt = convert_to_string(entrytxt) 6429 keep_elem_refs(pPopup, pPopupEntry, entrytxt, sentrytxt) 6430 retval = _fl_popup_insert_entries(pPopup, pPopupEntry, sentrytxt) 6431 return retval
6432 6433
6434 -def fl_popup_create(win, text, pPopupItem):
6435 """ fl_popup_create(win, text, pPopupItem) -> pPopup 6436 """ 6437 6438 _fl_popup_create = cfuncproto( 6439 load_so_libforms(), "fl_popup_create", 6440 cty.POINTER(FL_POPUP), [Window, STRING, 6441 cty.POINTER(FL_POPUP_ITEM)], 6442 """FL_POPUP * fl_popup_create(Window p1, const char * p2, 6443 FL_POPUP_ITEM * p3) 6444 """) 6445 ulwin = convert_to_Window(win) 6446 stext = convert_to_string(text) 6447 keep_elem_refs(win, text, pPopupItem, ulwin, stext) 6448 retval = _fl_popup_create(ulwin, stext, pPopupItem) 6449 return retval
6450 6451
6452 -def fl_popup_delete(pPopup):
6453 """ fl_popup_delete(pPopup) -> num. 6454 """ 6455 6456 _fl_popup_delete = cfuncproto( 6457 load_so_libforms(), "fl_popup_delete", 6458 cty.c_int, [cty.POINTER(FL_POPUP)], 6459 """int fl_popup_delete(FL_POPUP * p1) 6460 """) 6461 keep_elem_refs(pPopup) 6462 retval = _fl_popup_delete(pPopup) 6463 return retval
6464 6465
6466 -def fl_popup_entry_delete(pPopupEntry):
6467 """ fl_popup_entry_delete(pPopupEntry) -> num. 6468 """ 6469 6470 _fl_popup_entry_delete = cfuncproto( 6471 load_so_libforms(), "fl_popup_entry_delete", 6472 cty.c_int, [cty.POINTER(FL_POPUP_ENTRY)], 6473 """int fl_popup_entry_delete(FL_POPUP_ENTRY * p1) 6474 """) 6475 keep_elem_refs(pPopupEntry) 6476 retval = _fl_popup_entry_delete(pPopupEntry) 6477 return retval
6478 6479
6480 -def fl_popup_do(pPopup):
6481 """ fl_popup_do(pPopup) -> pPopupReturn 6482 """ 6483 6484 _fl_popup_do = cfuncproto( 6485 load_so_libforms(), "fl_popup_do", 6486 cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_POPUP)], 6487 """FL_POPUP_RETURN * fl_popup_do(FL_POPUP * p1) 6488 """) 6489 keep_elem_refs(pPopup) 6490 retval = _fl_popup_do(pPopup) 6491 return retval
6492 6493
6494 -def fl_popup_set_position(pPopup, x, y):
6495 """ 6496 fl_popup_set_position(pPopup, x, y) 6497 6498 Sets position where the popup is supposed to appear (if never called 6499 the popup appears at the mouse position) 6500 6501 @param pPopup : pointer to Popup 6502 @param x : horizontal position (upper-left corner) 6503 @param y : vertical position (upper-left corner) 6504 """ 6505 6506 _fl_popup_set_position = cfuncproto( 6507 load_so_libforms(), "fl_popup_set_position", 6508 None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 6509 """void fl_popup_set_position(FL_POPUP * p1, int p2, int p3) 6510 """) 6511 ix = convert_to_int(x) 6512 iy = convert_to_int(y) 6513 keep_elem_refs(pPopup, x, y, ix, iy) 6514 _fl_popup_set_position(pPopup, ix, iy)
6515 6516
6517 -def fl_popup_get_policy(pPopup):
6518 """ 6519 fl_popup_get_policy(pPopup) -> num. 6520 """ 6521 6522 _fl_popup_get_policy = cfuncproto( 6523 load_so_libforms(), "fl_popup_get_policy", 6524 cty.c_int, [cty.POINTER(FL_POPUP)], 6525 """int fl_popup_get_policy(FL_POPUP * p1) 6526 """) 6527 keep_elem_refs(pPopup) 6528 retval = _fl_popup_get_policy(pPopup) 6529 return retval
6530 6531
6532 -def fl_popup_set_policy(pPopup, policy):
6533 """ 6534 fl_popup_set_policy(pPopup, policy) -> num. 6535 6536 Sets policy of handling the popup (i.e. does it get closed when the 6537 user releases the mouse button outside an active entry or not?) 6538 6539 @param pPopup : pointer to Popup 6540 @param policy : policy to be set 6541 """ 6542 6543 _fl_popup_set_policy = cfuncproto( 6544 load_so_libforms(), "fl_popup_set_policy", 6545 cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 6546 """int fl_popup_set_policy(FL_POPUP * p1, int p2) 6547 """) 6548 ipolicy = convert_to_int(policy) 6549 keep_elem_refs(pPopup, policy, ipolicy) 6550 retval = _fl_popup_set_policy(pPopup, ipolicy) 6551 return retval
6552 6553 6554 # already defined in xfdata 6555 #FL_POPUP_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_POPUP_RETURN)) 6556
6557 -def fl_popup_set_callback(pPopup, py_PopupCb):
6558 """ 6559 fl_popup_set_callback(pPopup, py_PopupCb) -> popup callback func. 6560 """ 6561 6562 _fl_popup_set_callback = cfuncproto( 6563 load_so_libforms(), "fl_popup_set_callback", 6564 FL_POPUP_CB, [cty.POINTER(FL_POPUP), FL_POPUP_CB], 6565 """FL_POPUP_CB fl_popup_set_callback(FL_POPUP * p1, 6566 FL_POPUP_CB p2) 6567 """) 6568 c_PopupCb = FL_POPUP_CB(py_PopupCb) 6569 keep_cfunc_refs(c_PopupCb, py_PopupCb) 6570 keep_elem_refs(pPopup) 6571 retval = _fl_popup_set_callback(pPopup, c_PopupCb) 6572 return retval
6573 6574 6575 #def fl_popup_get_title_font(pPopup, style, size) *API change*
6576 -def fl_popup_get_title_font(pPopup):
6577 """ 6578 fl_popup_get_title_font(pPopup) -> style, size 6579 """ 6580 6581 _fl_popup_get_title_font = cfuncproto( 6582 load_so_libforms(), "fl_popup_get_title_font", 6583 None, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_int), 6584 cty.POINTER(cty.c_int)], 6585 """void fl_popup_get_title_font(FL_POPUP * p1, int * p2, 6586 int * p3) 6587 """) 6588 style, pstyle = make_int_and_pointer() 6589 size, psize = make_int_and_pointer() 6590 keep_elem_refs(pPopup, style, size, pstyle, psize) 6591 _fl_popup_get_title_font(pPopup, pstyle, psize) 6592 return style, size
6593 6594
6595 -def fl_popup_set_title_font(pPopup, style, size):
6596 """ 6597 fl_popup_set_title_font(pPopup, style, size) 6598 """ 6599 6600 _fl_popup_set_title_font = cfuncproto( 6601 load_so_libforms(), "fl_popup_set_title_font", 6602 None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 6603 """void fl_popup_set_title_font(FL_POPUP * p1, int p2, int p3) 6604 """) 6605 istyle = convert_to_int(style) 6606 isize = convert_to_int(size) 6607 keep_elem_refs(pPopup, style, size, istyle, isize) 6608 _fl_popup_set_title_font(pPopup, istyle, isize)
6609 6610 6611 #def fl_popup_entry_get_font(pPopup, style, size) *API change*
6612 -def fl_popup_entry_get_font(pPopup):
6613 """ 6614 fl_popup_entry_get_font(pPopup) -> style, size 6615 """ 6616 6617 _fl_popup_entry_get_font = cfuncproto( 6618 load_so_libforms(), "fl_popup_entry_get_font", 6619 None, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_int), 6620 cty.POINTER(cty.c_int)], 6621 """void fl_popup_entry_get_font(FL_POPUP * p1, int * p2, int * p3) 6622 """) 6623 style, pstyle = make_int_and_pointer() 6624 size, psize = make_int_and_pointer() 6625 keep_elem_refs(pPopup, style, size, pstyle, psize) 6626 _fl_popup_entry_get_font(pPopup, pstyle, psize) 6627 return style, size
6628 6629
6630 -def fl_popup_entry_set_font(pPopup, style, size):
6631 """ 6632 fl_popup_entry_set_font(pPopup, style, size) 6633 6634 Sets the font of a popup entry. 6635 6636 @param pPopup : pointer to Popup 6637 @param style : style of the popup entry 6638 @param size : size of the popup entry 6639 """ 6640 6641 _fl_popup_entry_set_font = cfuncproto( 6642 load_so_libforms(), "fl_popup_entry_set_font", 6643 None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 6644 """void fl_popup_entry_set_font(FL_POPUP * p1, int p2, int p3) 6645 """) 6646 istyle = convert_to_int(style) 6647 isize = convert_to_int(size) 6648 keep_elem_refs(pPopup, style, size, istyle, isize) 6649 _fl_popup_entry_set_font(pPopup, istyle, isize)
6650 6651
6652 -def fl_popup_get_bw(pPopup):
6653 """ 6654 fl_popup_get_bw(pPopup) -> borderwidth 6655 6656 Returns the border width of a popup. 6657 6658 @param pPopup : pointer to popup 6659 """ 6660 6661 _fl_popup_get_bw = cfuncproto( 6662 load_so_libforms(), "fl_popup_get_bw", 6663 cty.c_int, [cty.POINTER(FL_POPUP)], 6664 """int fl_popup_get_bw(FL_POPUP * p1) 6665 """) 6666 keep_elem_refs(pPopup) 6667 retval = _fl_popup_get_bw(pPopup) 6668 return retval
6669 6670
6671 -def fl_popup_set_bw(pPopup, bw):
6672 """ 6673 fl_popup_set_bw(pPopup, bw) -> num. 6674 6675 Sets the border width of a popup. 6676 6677 @param pPopup : pointer to popup 6678 @param bw : border width value to be set 6679 """ 6680 6681 _fl_popup_set_bw = cfuncproto( 6682 load_so_libforms(), "fl_popup_set_bw", 6683 cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 6684 """int fl_popup_set_bw(FL_POPUP * p1, int p2) 6685 """) 6686 ibw = convert_to_int(bw) 6687 keep_elem_refs(pPopup, bw, ibw) 6688 retval = _fl_popup_set_bw(pPopup, ibw) 6689 return retval
6690 6691
6692 -def fl_popup_get_color(pPopup, p2):
6693 """ 6694 fl_popup_get_color(pPopup, p2) -> color 6695 """ 6696 6697 _fl_popup_get_color = cfuncproto( 6698 load_so_libforms(), "fl_popup_get_color", 6699 FL_COLOR, [cty.POINTER(FL_POPUP), cty.c_int], 6700 """FL_COLOR fl_popup_get_color(FL_POPUP * p1, int p2) 6701 """) 6702 ip2 = convert_to_int(p2) 6703 keep_elem_refs(pPopup, p2, ip2) 6704 retval = _fl_popup_get_color(pPopup, ip2) 6705 return retval
6706 6707
6708 -def fl_popup_set_color(pPopup, p2, colr):
6709 """ fl_popup_set_color(pPopup, p2, colr) -> color 6710 """ 6711 6712 _fl_popup_set_color = cfuncproto( 6713 load_so_libforms(), "fl_popup_set_color", 6714 FL_COLOR, [cty.POINTER(FL_POPUP), cty.c_int, FL_COLOR], 6715 """FL_COLOR fl_popup_set_color(FL_POPUP * p1, int p2, FL_COLOR p3) 6716 """) 6717 check_admitted_listvalues(colr, COLOR_list) 6718 ip2 = convert_to_int(p2) 6719 ulcolr = convert_to_FL_COLOR(colr) 6720 keep_elem_refs(pPopup, p2, colr, ip2, ulcolr) 6721 retval = _fl_popup_set_color(pPopup, ip2, ulcolr) 6722 return retval
6723 6724
6725 -def fl_popup_set_cursor(pPopup, cursnum):
6726 """ 6727 fl_popup_set_cursor(pPopup, cursnum) 6728 """ 6729 6730 _fl_popup_set_cursor = cfuncproto( 6731 load_so_libforms(), "fl_popup_set_cursor", 6732 None, [cty.POINTER(FL_POPUP), cty.c_int], 6733 """void fl_popup_set_cursor(FL_POPUP * p1, int p2) 6734 """) 6735 icursnum = convert_to_int(cursnum) 6736 keep_elem_refs(pPopup, cursnum, icursnum) 6737 _fl_popup_set_cursor(pPopup, icursnum)
6738 6739
6740 -def fl_popup_get_title(pPopup):
6741 """ 6742 fl_popup_get_title(pPopup) -> title string 6743 6744 Returns the title of a popup. 6745 6746 @param pPopup : pointer to popup 6747 """ 6748 6749 _fl_popup_get_title = cfuncproto( 6750 load_so_libforms(), "fl_popup_get_title", 6751 STRING, [cty.POINTER(FL_POPUP)], 6752 """const char * fl_popup_get_title(FL_POPUP * p1) 6753 """) 6754 keep_elem_refs(pPopup) 6755 retval = _fl_popup_get_title(pPopup) 6756 return retval
6757 6758
6759 -def fl_popup_set_title(pPopup, title):
6760 """ fl_popup_set_title(pPopup, title) -> popup 6761 6762 Sets the title of a popup. 6763 6764 @param pPopup : pointer to popup 6765 @param title : title of the popup 6766 """ 6767 6768 _fl_popup_set_title = cfuncproto( 6769 load_so_libforms(), "fl_popup_set_title", 6770 cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP), STRING], 6771 """FL_POPUP * fl_popup_set_title(FL_POPUP * p1, const char * p2) 6772 """) 6773 stitle = convert_to_string(title) 6774 keep_elem_refs(pPopup, title, stitle) 6775 retval = _fl_popup_set_title(pPopup, stitle) 6776 return retval
6777 6778
6779 -def fl_popup_entry_set_callback(pPopupEntry, py_PopupCb):
6780 """ fl_popup_entry_set_callback(pPopupEntry, py_PopupCb) -> popup_callback 6781 """ 6782 6783 _fl_popup_entry_set_callback = cfuncproto( 6784 load_so_libforms(), "fl_popup_entry_set_callback", 6785 FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 6786 """FL_POPUP_CB fl_popup_entry_set_callback(FL_POPUP_ENTRY * p1, 6787 FL_POPUP_CB p2) 6788 """) 6789 c_PopupCb = FL_POPUP_CB(py_PopupCb) 6790 keep_cfunc_refs(c_PopupCb, py_PopupCb) 6791 keep_elem_refs(pPopupEntry) 6792 retval = _fl_popup_entry_set_callback(pPopupEntry, c_PopupCb) 6793 return retval
6794 6795
6796 -def fl_popup_entry_set_enter_callback(pPopupEntry, py_PopupCb):
6797 """ fl_popup_entry_set_enter_callback(pPopupEntry, py_PopupCb) -> popup_callback 6798 """ 6799 6800 _fl_popup_entry_set_enter_callback = cfuncproto( 6801 load_so_libforms(), "fl_popup_entry_set_enter_callback", 6802 FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 6803 """FL_POPUP_CB fl_popup_entry_set_enter_callback( 6804 FL_POPUP_ENTRY * p1, FL_POPUP_CB p2) 6805 """) 6806 c_PopupCb = FL_POPUP_CB(py_PopupCb) 6807 keep_cfunc_refs(c_PopupCb, py_PopupCb) 6808 keep_elem_refs(pPopupEntry) 6809 retval = _fl_popup_entry_set_enter_callback(pPopupEntry, c_PopupCb) 6810 return retval
6811 6812
6813 -def fl_popup_entry_set_leave_callback(pPopupEntry, py_PopupCb):
6814 """ fl_popup_entry_set_leave_callback(pPopupEntry, py_PopupCb) -> popup_callback 6815 """ 6816 6817 _fl_popup_entry_set_leave_callback = cfuncproto( 6818 load_so_libforms(), "fl_popup_entry_set_leave_callback", 6819 FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 6820 """FL_POPUP_CB fl_popup_entry_set_leave_callback( 6821 FL_POPUP_ENTRY * p1, FL_POPUP_CB p2) 6822 """) 6823 c_PopupCb = FL_POPUP_CB(py_PopupCb) 6824 keep_cfunc_refs(c_PopupCb, py_PopupCb) 6825 keep_elem_refs(pPopupEntry) 6826 retval = _fl_popup_entry_set_leave_callback(pPopupEntry, c_PopupCb) 6827 return retval
6828 6829
6830 -def fl_popup_entry_get_state(pPopupEntry):
6831 """ fl_popup_entry_get_state(pPopupEntry) -> state num. 6832 """ 6833 6834 _fl_popup_entry_get_state = cfuncproto( 6835 load_so_libforms(), "fl_popup_entry_get_state", 6836 cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY)], 6837 """unsigned int fl_popup_entry_get_state(FL_POPUP_ENTRY * p1) 6838 """) 6839 keep_elem_refs(pPopupEntry) 6840 retval = _fl_popup_entry_get_state(pPopupEntry) 6841 return retval
6842 6843
6844 -def fl_popup_entry_set_state(pPopupEntry, state):
6845 """ fl_popup_entry_set_state(pPopupEntry, state) -> state num. 6846 """ 6847 6848 _fl_popup_entry_set_state = cfuncproto( 6849 load_so_libforms(), "fl_popup_entry_set_state", 6850 cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 6851 """unsigned int fl_popup_entry_set_state(FL_POPUP_ENTRY * p1, 6852 unsigned int p2) 6853 """) 6854 uistate = convert_to_uint(state) 6855 keep_elem_refs(pPopupEntry, state, uistate) 6856 retval = _fl_popup_entry_set_state(pPopupEntry, uistate) 6857 return retval
6858 6859
6860 -def fl_popup_entry_clear_state(pPopupEntry, state):
6861 """ fl_popup_entry_clear_state(pPopupEntry, state) -> state num. 6862 """ 6863 6864 _fl_popup_entry_clear_state = cfuncproto( 6865 load_so_libforms(), "fl_popup_entry_clear_state", 6866 cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 6867 """unsigned int fl_popup_entry_clear_state(FL_POPUP_ENTRY * p1, 6868 unsigned int p2) 6869 """) 6870 uistate = convert_to_uint(state) 6871 keep_elem_refs(pPopupEntry, state, uistate) 6872 retval = _fl_popup_entry_clear_state(pPopupEntry, uistate) 6873 return retval
6874 6875
6876 -def fl_popup_entry_raise_state(pPopupEntry, state):
6877 """ fl_popup_entry_raise_state(pPopupEntry, state) -> state num. 6878 """ 6879 6880 _fl_popup_entry_raise_state = cfuncproto( 6881 load_so_libforms(), "fl_popup_entry_raise_state", 6882 cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 6883 """unsigned int fl_popup_entry_raise_state(FL_POPUP_ENTRY * p1, 6884 unsigned int p2) 6885 """) 6886 uistate = convert_to_uint(state) 6887 keep_elem_refs(pPopupEntry, state, uistate) 6888 retval = _fl_popup_entry_raise_state(pPopupEntry, uistate) 6889 return retval
6890 6891
6892 -def fl_popup_entry_toggle_state(pPopupEntry, state):
6893 """ fl_popup_entry_toggle_state(pPopupEntry, state) -> num. 6894 """ 6895 6896 _fl_popup_entry_toggle_state = cfuncproto( 6897 load_so_libforms(), "fl_popup_entry_toggle_state", 6898 cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 6899 """unsigned int fl_popup_entry_toggle_state(FL_POPUP_ENTRY * p1, 6900 unsigned int p2) 6901 """) 6902 uistate = convert_to_uint(state) 6903 keep_elem_refs(pPopupEntry, state, uistate) 6904 retval = _fl_popup_entry_toggle_state(pPopupEntry, uistate) 6905 return retval
6906 6907
6908 -def fl_popup_entry_set_text(pPopupEntry, text):
6909 """ fl_popup_entry_set_text(p1, txtstr) -> num. 6910 """ 6911 6912 _fl_popup_entry_set_text = cfuncproto( 6913 load_so_libforms(), "fl_popup_entry_set_text", 6914 cty.c_int, [cty.POINTER(FL_POPUP_ENTRY), STRING], 6915 """int fl_popup_entry_set_text(FL_POPUP_ENTRY * p1, 6916 const char * p2) 6917 """) 6918 stext = convert_to_string(text) 6919 keep_elem_refs(pPopupEntry, text, stext) 6920 retval = _fl_popup_entry_set_text(pPopupEntry, stext) 6921 return retval
6922 6923
6924 -def fl_popup_entry_set_shortcut(pPopupEntry, textsc):
6925 """ fl_popup_entry_set_shortcut(pPopupEntry, textsc) 6926 """ 6927 6928 _fl_popup_entry_set_shortcut = cfuncproto( 6929 load_so_libforms(), "fl_popup_entry_set_shortcut", 6930 None, [cty.POINTER(FL_POPUP_ENTRY), STRING], 6931 """void fl_popup_entry_set_shortcut(FL_POPUP_ENTRY * p1, 6932 const char * p2) 6933 """) 6934 stextsc = convert_to_string(textsc) 6935 keep_elem_refs(pPopupEntry, textsc, stextsc) 6936 _fl_popup_entry_set_shortcut(pPopupEntry, stextsc)
6937 6938
6939 -def fl_popup_entry_set_value(pPopupEntry, val):
6940 """ fl_popup_entry_set_value(pPopupEntry, p2) -> num. 6941 """ 6942 6943 _fl_popup_entry_set_value = cfuncproto( 6944 load_so_libforms(), "fl_popup_entry_set_value", 6945 cty.c_long, [cty.POINTER(FL_POPUP_ENTRY), cty.c_long], 6946 """long int fl_popup_entry_set_value(FL_POPUP_ENTRY * p1, 6947 long int p2) 6948 """) 6949 lval = convert_to_long(val) 6950 keep_elem_refs(pPopupEntry, val, lval) 6951 retval = _fl_popup_entry_set_value(pPopupEntry, lval) 6952 return retval
6953 6954
6955 -def fl_popup_entry_set_user_data(pPopupEntry, data):
6956 """ fl_popup_entry_set_user_data(pPopupEntry, data) -> ?? 6957 """ 6958 6959 _fl_popup_entry_set_user_data = cfuncproto( 6960 load_so_libforms(), "fl_popup_entry_set_user_data", 6961 cty.c_void_p, [cty.POINTER(FL_POPUP_ENTRY), cty.c_void_p], 6962 """void * fl_popup_entry_set_user_data(FL_POPUP_ENTRY * p1, 6963 void * p2) 6964 """) 6965 pdata = cty.cast(data, cty.c_void_p) 6966 keep_elem_refs(pPopupEntry, data, pdata) 6967 retval = _fl_popup_entry_set_user_data(pPopupEntry, pdata) 6968 return retval
6969 6970
6971 -def fl_popup_entry_get_by_position(pPopup, numpos):
6972 """ fl_popup_entry_get_by_position(pPopup, numpos) -> pPopupEntry 6973 """ 6974 6975 _fl_popup_entry_get_by_position = cfuncproto( 6976 load_so_libforms(), "fl_popup_entry_get_by_position", 6977 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_int], 6978 """FL_POPUP_ENTRY * fl_popup_entry_get_by_position(FL_POPUP * p1, 6979 int p2) 6980 """) 6981 inumpos = convert_to_int(numpos) 6982 keep_elem_refs(pPopup, numpos, inumpos) 6983 retval = _fl_popup_entry_get_by_position(pPopup, inumpos) 6984 return retval
6985 6986
6987 -def fl_popup_entry_get_by_value(pPopup, val):
6988 """ fl_popup_entry_get_by_value(pPopup, val) -> pPopupEntry 6989 """ 6990 6991 _fl_popup_entry_get_by_value = cfuncproto( 6992 load_so_libforms(), "fl_popup_entry_get_by_value", 6993 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_long], 6994 """FL_POPUP_ENTRY * fl_popup_entry_get_by_value(FL_POPUP * p1, 6995 long int p2) 6996 """) 6997 lval = convert_to_long(val) 6998 keep_elem_refs(pPopup, val, lval) 6999 retval = _fl_popup_entry_get_by_value(pPopup, lval) 7000 return retval
7001 7002
7003 -def fl_popup_entry_get_by_user_data(pPopup, userdata):
7004 """ fl_popup_entry_get_by_user_data(pPopup, userdata) -> pPopupEntry 7005 """ 7006 7007 _fl_popup_entry_get_by_user_data = cfuncproto( 7008 load_so_libforms(), "fl_popup_entry_get_by_user_data", 7009 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_void_p], 7010 """FL_POPUP_ENTRY * fl_popup_entry_get_by_user_data(FL_POPUP * p1, 7011 void * p2) 7012 """) 7013 puserdata = cty.cast(userdata, cty.c_void_p) 7014 keep_elem_refs(pPopup, userdata, puserdata) 7015 retval = _fl_popup_entry_get_by_user_data(pPopup, puserdata) 7016 return retval
7017 7018
7019 -def fl_popup_entry_get_by_text(pPopup, text):
7020 """ fl_popup_entry_get_by_text(pPopup, text) -> pPopupEntry 7021 """ 7022 7023 _fl_popup_entry_get_by_text = cfuncproto( 7024 load_so_libforms(), "fl_popup_entry_get_by_text", 7025 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 7026 """FL_POPUP_ENTRY * fl_popup_entry_get_by_text(FL_POPUP * p1, 7027 const char * p2) 7028 """) 7029 stext = convert_to_string(text) 7030 keep_elem_refs(pPopup, text, stext) 7031 retval = _fl_popup_entry_get_by_text(pPopup, stext) 7032 return retval
7033 7034
7035 -def fl_popup_entry_get_by_label(pPopup, label):
7036 """ fl_popup_entry_get_by_label(pPopup, label) -> pPopupEntry 7037 """ 7038 7039 _fl_popup_entry_get_by_label = cfuncproto( 7040 load_so_libforms(), "fl_popup_entry_get_by_label", 7041 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 7042 """FL_POPUP_ENTRY * fl_popup_entry_get_by_label(FL_POPUP * p1, 7043 const char * p2) 7044 """) 7045 slabel = convert_to_string(label) 7046 keep_elem_refs(pPopup, label, slabel) 7047 retval = _fl_popup_entry_get_by_label(pPopup, slabel) 7048 return retval
7049 7050
7051 -def fl_popup_entry_get_group(pPopupEntry):
7052 """ fl_popup_entry_get_group(pPopupEntry) -> num. 7053 """ 7054 7055 _fl_popup_entry_get_group = cfuncproto( 7056 load_so_libforms(), "fl_popup_entry_get_group", 7057 cty.c_int, [cty.POINTER(FL_POPUP_ENTRY)], 7058 """int fl_popup_entry_get_group(FL_POPUP_ENTRY * p1) 7059 """) 7060 keep_elem_refs(pPopupEntry) 7061 retval = _fl_popup_entry_get_group(pPopupEntry) 7062 return retval
7063 7064
7065 -def fl_popup_entry_set_group(pPopupEntry, num):
7066 """ fl_popup_entry_set_group(pPopupEntry, num) -> num. 7067 """ 7068 7069 _fl_popup_entry_set_group = cfuncproto( 7070 load_so_libforms(), "fl_popup_entry_set_group", 7071 cty.c_int, [cty.POINTER(FL_POPUP_ENTRY), cty.c_int], 7072 """int fl_popup_entry_set_group(FL_POPUP_ENTRY * p1, int p2) 7073 """) 7074 inum = convert_to_int(num) 7075 keep_elem_refs(pPopupEntry, num, inum) 7076 retval = _fl_popup_entry_set_group(pPopupEntry, inum) 7077 return retval
7078 7079
7080 -def fl_popup_entry_get_subpopup(pPopupEntry):
7081 """ fl_popup_entry_get_subpopup(pPopupEntry) -> pPopup 7082 """ 7083 7084 _fl_popup_entry_get_subpopup = cfuncproto( 7085 load_so_libforms(), "fl_popup_entry_get_subpopup", 7086 cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP_ENTRY)], 7087 """FL_POPUP * fl_popup_entry_get_subpopup(FL_POPUP_ENTRY * p1) 7088 """) 7089 keep_elem_refs(pPopupEntry) 7090 retval = _fl_popup_entry_get_subpopup(pPopupEntry) 7091 return retval
7092 7093
7094 -def fl_popup_entry_set_subpopup(pPopupEntry, pPopup):
7095 """ fl_popup_entry_set_subpopup(pPopupEntry, pPopup) -> pPopup 7096 """ 7097 7098 _fl_popup_entry_set_subpopup = cfuncproto( 7099 load_so_libforms(), "fl_popup_entry_set_subpopup", 7100 cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP_ENTRY), 7101 cty.POINTER(FL_POPUP)], 7102 """FL_POPUP * fl_popup_entry_set_subpopup(FL_POPUP_ENTRY * p1, 7103 FL_POPUP * p2) 7104 """) 7105 keep_elem_refs(pPopupEntry, pPopup) 7106 retval = _fl_popup_entry_set_subpopup(pPopupEntry, pPopup) 7107 return retval
7108 7109 7110 #def fl_popup_get_size(pPopup, w, h) *API change*
7111 -def fl_popup_get_size(pPopup):
7112 """ fl_popup_get_size(pPopup) -> size num., width, height 7113 """ 7114 7115 _fl_popup_get_size = cfuncproto( 7116 load_so_libforms(), "fl_popup_get_size", 7117 cty.c_int, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_uint), 7118 cty.POINTER(cty.c_uint)], 7119 """int fl_popup_get_size(FL_POPUP * p1, unsigned int * p2, 7120 unsigned int * p3) 7121 """) 7122 w, pw = make_uint_and_pointer() 7123 h, ph = make_uint_and_pointer() 7124 keep_elem_refs(pPopup, w, h, pw, ph) 7125 retval = _fl_popup_get_size(pPopup, pw, ph) 7126 return retval, w, h
7127 7128
7129 -def fl_popup_get_min_width(pPopup):
7130 """ fl_popup_get_min_width(pPopup) -> width num. 7131 """ 7132 7133 _fl_popup_get_min_width = cfuncproto( 7134 load_so_libforms(), "fl_popup_get_min_width", 7135 cty.c_int, [cty.POINTER(FL_POPUP)], 7136 """int fl_popup_get_min_width(FL_POPUP * p1) 7137 """) 7138 keep_elem_refs(pPopup) 7139 retval = _fl_popup_get_min_width(pPopup) 7140 return retval
7141 7142
7143 -def fl_popup_set_min_width(pPopup, minwidth):
7144 """ fl_popup_set_min_width(pPopup, minwidth) -> width num. 7145 """ 7146 7147 _fl_popup_set_min_width = cfuncproto( 7148 load_so_libforms(), "fl_popup_set_min_width", 7149 cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 7150 """int fl_popup_set_min_width(FL_POPUP * p1, int p2) 7151 """) 7152 iminwidth = convert_to_int(minwidth) 7153 keep_elem_refs(pPopup, minwidth, iminwidth) 7154 retval = _fl_popup_set_min_width(pPopup, iminwidth) 7155 return retval
7156 7157 7158 7159 ####################### 7160 # forms.h (bitmap.h) 7161 # Object Class: Bitmap 7162 ####################### 7163 7164 7165 # Routines 7166
7167 -def fl_create_bitmap(bitmaptype, x, y, w, h, label):
7168 """ 7169 fl_create_bitmap(bitmaptype, x, y, w, h, label) -> pObject 7170 7171 Creates a bitmap object. 7172 7173 @param bitmaptype : type of bitmap to create 7174 @param x : horizontal position of bitmap (upper-left corner) 7175 @param y : vertical position of bitmap (upper-left corner) 7176 @param w : width of bitmap in pixels 7177 @param h : height of bitmap in pixels 7178 @param label : text label of bitmap 7179 """ 7180 7181 _fl_create_bitmap = cfuncproto( 7182 load_so_libforms(), "fl_create_bitmap", 7183 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7184 FL_Coord, STRING], 7185 """FL_OBJECT * fl_create_bitmap(int type, FL_Coord x, FL_Coord y, 7186 FL_Coord w, FL_Coord h, const char * label) 7187 """) 7188 check_admitted_listvalues(bitmaptype, BITMAPTYPE_list) 7189 ibitmaptype = convert_to_int(bitmaptype) 7190 ix = convert_to_FL_Coord(x) 7191 iy = convert_to_FL_Coord(y) 7192 iw = convert_to_FL_Coord(w) 7193 ih = convert_to_FL_Coord(h) 7194 slabel = convert_to_int(label) 7195 keep_elem_refs(bitmaptype, x, y, w, h, label, ibitmaptype, ix, iy, 7196 iw, ih, slabel) 7197 retval = _fl_create_bitmap(ibitmaptype, ix, iy, iw, ih, slabel) 7198 return retval
7199 7200
7201 -def fl_add_bitmap(bitmaptype, x, y, w, h, label):
7202 """ 7203 fl_add_bitmap(bitmaptype, x, y, w, h, label) -> pObject 7204 7205 Adds a bitmap object. 7206 7207 @param bitmaptype : type of bitmap to be added 7208 @param x : horizontal position of bitmap (upper-left corner) 7209 @param y : vertical position of bitmap (upper-left corner) 7210 @param w : width of bitmap in pixels 7211 @param h : height of bitmap in pixels 7212 @param label : text label of bitmap 7213 """ 7214 7215 _fl_add_bitmap = cfuncproto( 7216 load_so_libforms(), "fl_add_bitmap", 7217 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7218 FL_Coord, STRING], 7219 """FL_OBJECT * fl_add_bitmap(int type, FL_Coord x, FL_Coord y, 7220 FL_Coord w, FL_Coord h, const char * label) 7221 """) 7222 check_admitted_listvalues(bitmaptype, BITMAPTYPE_list) 7223 ibitmaptype = convert_to_int(bitmaptype) 7224 ix = convert_to_FL_Coord(x) 7225 iy = convert_to_FL_Coord(y) 7226 iw = convert_to_FL_Coord(w) 7227 ih = convert_to_FL_Coord(h) 7228 slabel = convert_to_string(label) 7229 keep_elem_refs(bitmaptype, x, y, w, h, label, ibitmaptype, ix, iy, iw, 7230 ih, slabel) 7231 retval = _fl_add_bitmap(ibitmaptype, ix, iy, iw, ih, slabel) 7232 return retval
7233 7234
7235 -def fl_set_bitmap_data(pObject, w, h, xbmcontents):
7236 """ fl_set_bitmap_data(pObject, w, h, xbmcontents) 7237 7238 Fills the bitmap with a bitmap. 7239 7240 @param pObject : pointer to object 7241 @param w : width of bitmap in pixels 7242 @param h : height of bitmap in pixels 7243 @param xbmcontents : bitmap data used for contents in ubytes 7244 """ 7245 7246 _fl_set_bitmap_data = cfuncproto( 7247 load_so_libforms(), "fl_set_bitmap_data", 7248 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 7249 cty.POINTER(cty.c_ubyte)], 7250 """void fl_set_bitmap_data(FL_OBJECT * ob, int w, int h, 7251 unsigned char * data) 7252 """) 7253 iw = convert_to_int(w) 7254 ih = convert_to_int(h) 7255 pxbmcontents = cty.cast(xbmcontents, cty.POINTER(cty.c_ubyte)) 7256 keep_elem_refs(pObject, w, h, xbmcontents, iw, ih, pxbmcontents) 7257 _fl_set_bitmap_data(pObject, iw, ih, pxbmcontents)
7258 7259
7260 -def fl_set_bitmap_file(pObject, fname):
7261 """ fl_set_bitmap_file(pObject, fname) 7262 7263 @param pObject : pointer to object 7264 @param fname : name of bitmap file 7265 """ 7266 7267 _fl_set_bitmap_file = cfuncproto( 7268 load_so_libforms(), "fl_set_bitmap_file", 7269 None, [cty.POINTER(FL_OBJECT), STRING], 7270 """void fl_set_bitmap_file(FL_OBJECT * ob, const char * fname) 7271 """) 7272 sfname = convert_to_string(fname) 7273 keep_elem_refs(pObject, fname, sfname) 7274 _fl_set_bitmap_file(pObject, sfname)
7275 7276
7277 -def fl_read_bitmapfile(win, filename, w, h, hotx, hoty):
7278 """ fl_read_bitmapfile(win, filename, w, h, hotx, hoty) -> pixmap 7279 """ 7280 7281 _fl_read_bitmapfile = cfuncproto( 7282 load_so_libforms(), "fl_read_bitmapfile", 7283 Pixmap, [Window, STRING, cty.POINTER(cty.c_uint), 7284 cty.POINTER(cty.c_uint), cty.POINTER(cty.c_int), 7285 cty.POINTER(cty.c_int)], 7286 """Pixmap fl_read_bitmapfile(Window win, const char * file, 7287 unsigned int * w, unsigned int * h, int * hotx, int * hoty) 7288 """) 7289 ulwin = convert_to_Window(win) 7290 sfilename = convert_to_string(filename) 7291 pw = cty.cast(w, cty.POINTER(cty.c_uint)) 7292 ph = cty.cast(h, cty.POINTER(cty.c_uint)) 7293 photx = cty.cast(hotx, cty.POINTER(cty.c_int)) 7294 photy = cty.cast(hoty, cty.POINTER(cty.c_int)) 7295 keep_elem_refs(win, filename, w, h, hotx, hoty, ulwin, sfilename, 7296 pw, ph, photx, photy) 7297 retval = _fl_read_bitmapfile(ulwin, sfilename, pw, ph, photx, photy) 7298 return retval
7299 7300
7301 -def fl_create_from_bitmapdata(win, data, w, h):
7302 """ 7303 fl_create_from_bitmapdata(win, data, w, h) -> pixmap 7304 7305 @param win : window 7306 @param data : bitmap data 7307 @param w : width of bitmap in pixels 7308 @param h : height of bitmap in pixels 7309 """ 7310 7311 _fl_create_from_bitmapdata = cfuncproto( 7312 load_so_libforms(), "fl_create_from_bitmapdata", 7313 Pixmap, [Window, STRING, cty.c_int, cty.c_int], 7314 """Pixmap fl_create_from_bitmapdata(Window win, const 7315 char * data, int width, int height) 7316 """) 7317 ulwin = convert_to_ulong(win) 7318 sdata = convert_to_string(data) 7319 iw = convert_to_int(w) 7320 ih = convert_to_int(h) 7321 keep_elem_refs(win, data, w, h, ulwin, sdata, iw, ih) 7322 retval = _fl_create_from_bitmapdata(ulwin, sdata, iw, ih) 7323 return retval
7324 7325 7326 # for compatibility 7327 fl_set_bitmap_datafile = fl_set_bitmap_file 7328 7329 7330 # PIXMAP stuff 7331
7332 -def fl_create_pixmap(pixmaptype, x, y, w, h, label):
7333 """ fl_create_pixmap(pixmaptype, x, y, w, h, label) -> pObject 7334 """ 7335 7336 _fl_create_pixmap = cfuncproto( 7337 load_so_libforms(), "fl_create_pixmap", 7338 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7339 FL_Coord, STRING], 7340 """FL_OBJECT * fl_create_pixmap(int type, FL_Coord x, FL_Coord y, 7341 FL_Coord w, FL_Coord h, const char * label) 7342 """) 7343 check_admitted_listvalues(pixmaptype, PIXMAPTYPE_list) 7344 ipixmaptype = convert_to_int(pixmaptype) 7345 ix = convert_to_FL_Coord(x) 7346 iy = convert_to_FL_Coord(y) 7347 iw = convert_to_FL_Coord(w) 7348 ih = convert_to_FL_Coord(h) 7349 slabel = convert_to_string(label) 7350 keep_elem_refs(pixmaptype, x, y, w, h, label, ipixmaptype, ix, iy, iw, 7351 ih, slabel) 7352 retval = _fl_create_pixmap(ipixmaptype, ix, iy, iw, ih, slabel) 7353 return retval
7354 7355
7356 -def fl_add_pixmap(pixmaptype, x, y, w, h, label):
7357 """ fl_add_pixmap(pixmaptype, x, y, w, h, label) -> pObject 7358 """ 7359 7360 _fl_add_pixmap = cfuncproto( 7361 load_so_libforms(), "fl_add_pixmap", 7362 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7363 FL_Coord, STRING], 7364 """FL_OBJECT * fl_add_pixmap(int type, FL_Coord x, FL_Coord y, 7365 FL_Coord w, FL_Coord h, const char * label) 7366 """) 7367 check_admitted_listvalues(pixmaptype, PIXMAPTYPE_list) 7368 ipixmaptype = convert_to_int(pixmaptype) 7369 ix = convert_to_FL_Coord(x) 7370 iy = convert_to_FL_Coord(y) 7371 iw = convert_to_FL_Coord(w) 7372 ih = convert_to_FL_Coord(h) 7373 slabel = convert_to_string(label) 7374 keep_elem_refs(pixmaptype, x, y, w, h, label, ipixmaptype, ix, iy, iw, 7375 ih, slabel) 7376 retval = _fl_add_pixmap(ipixmaptype, ix, iy, iw, ih, slabel) 7377 return retval
7378 7379
7380 -def fl_set_pixmap_data(pObject, bits):
7381 """ fl_set_pixmap_data(pObject, bits) 7382 """ 7383 7384 _fl_set_pixmap_data = cfuncproto( 7385 load_so_libforms(), "fl_set_pixmap_data", 7386 None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING)], 7387 """void fl_set_pixmap_data(FL_OBJECT * ob, char * * bits) 7388 """) 7389 keep_elem_refs(pObject, bits) 7390 _fl_set_pixmap_data(pObject, bits)
7391 7392
7393 -def fl_set_pixmap_file(pObject, fname):
7394 """ fl_set_pixmap_file(pObject, fname) 7395 7396 @param pObject : pointer to object 7397 @param fname : name of the pixmap file 7398 """ 7399 7400 _fl_set_pixmap_file = cfuncproto( 7401 load_so_libforms(), "fl_set_pixmap_file", 7402 None, [cty.POINTER(FL_OBJECT), STRING], 7403 """void fl_set_pixmap_file(FL_OBJECT * ob, const char * fname) 7404 """) 7405 sfname = convert_to_string(fname) 7406 keep_elem_refs(pObject, fname, sfname) 7407 _fl_set_pixmap_file(pObject, sfname)
7408 7409
7410 -def fl_set_pixmap_align(pObject, align, xmargin, ymargin):
7411 """ fl_set_pixmap_align(pObject, align, xmargin, ymargin) 7412 """ 7413 7414 _fl_set_pixmap_align = cfuncproto( 7415 load_so_libforms(), "fl_set_pixmap_align", 7416 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, cty.c_int], 7417 """void fl_set_pixmap_align(FL_OBJECT * ob, int align, 7418 int xmargin, int ymargin) 7419 """) 7420 check_admitted_listvalues(align, ALIGN_list) 7421 ialign = convert_to_int(align) 7422 ixmargin = convert_to_int(xmargin) 7423 iymargin = convert_to_int(ymargin) 7424 keep_elem_refs(pObject, align, xmargin, ymargin, ialign, ixmargin, 7425 iymargin) 7426 _fl_set_pixmap_align(pObject, ialign, ixmargin, iymargin)
7427 7428
7429 -def fl_set_pixmap_pixmap(pObject, idnum, mask):
7430 """ fl_set_pixmap_pixmap(pObject, idnum, mask) 7431 """ 7432 7433 _fl_set_pixmap_pixmap = cfuncproto( 7434 load_so_libforms(), "fl_set_pixmap_pixmap", 7435 None, [cty.POINTER(FL_OBJECT), Pixmap, Pixmap], 7436 """void fl_set_pixmap_pixmap(FL_OBJECT * ob, Pixmap id, 7437 Pixmap mask) 7438 """) 7439 ulidnum = convert_to_ulong(idnum) 7440 ulmask = convert_to_ulong(mask) 7441 keep_elem_refs(pObject, idnum, mask, ulidnum, ulmask) 7442 _fl_set_pixmap_pixmap(pObject, ulidnum, ulmask)
7443 7444
7445 -def fl_set_pixmap_colorcloseness(red, green, blue):
7446 """ fl_set_pixmap_colorcloseness(red, green, blue) 7447 """ 7448 7449 _fl_set_pixmap_colorcloseness = cfuncproto( 7450 load_so_libforms(), "fl_set_pixmap_colorcloseness", 7451 None, [cty.c_int, cty.c_int, cty.c_int], 7452 """void fl_set_pixmap_colorcloseness(int red, int green, int blue) 7453 """) 7454 ired = convert_to_int(red) 7455 igreen = convert_to_int(green) 7456 iblue = convert_to_int(blue) 7457 keep_elem_refs(red, green, blue, ired, igreen, iblue) 7458 _fl_set_pixmap_colorcloseness(ired, igreen, iblue)
7459 7460
7461 -def fl_free_pixmap_pixmap(pObject):
7462 """ fl_free_pixmap_pixmap(pObject) 7463 7464 @param pObject : pointer to object 7465 """ 7466 7467 _fl_free_pixmap_pixmap = cfuncproto( 7468 load_so_libforms(), "fl_free_pixmap_pixmap", 7469 None, [cty.POINTER(FL_OBJECT)], 7470 """void fl_free_pixmap_pixmap(FL_OBJECT * ob) 7471 """) 7472 keep_elem_refs(pObject) 7473 _fl_free_pixmap_pixmap(pObject)
7474 7475 7476 #def fl_get_pixmap_pixmap(pObject, p, m) *API change*
7477 -def fl_get_pixmap_pixmap(pObject):
7478 """ fl_get_pixmap_pixmap(pObject) -> pixmap, pPixmap, pPixmap_mask 7479 7480 @param pObject : pointer to object 7481 """ 7482 7483 _fl_get_pixmap_pixmap = cfuncproto( 7484 load_so_libforms(), "fl_get_pixmap_pixmap", 7485 Pixmap, [cty.POINTER(FL_OBJECT), cty.POINTER(Pixmap), 7486 cty.POINTER(Pixmap)], 7487 """Pixmap fl_get_pixmap_pixmap(FL_OBJECT * ob, Pixmap * p, 7488 Pixmap * m) 7489 """) 7490 p, pp = make_ulong_and_pointer() 7491 m, pm = make_ulong_and_pointer() 7492 keep_elem_refs(pObject, p, m, pp, pm) 7493 retval = _fl_get_pixmap_pixmap(pObject, pp, pm) 7494 return retval, p, m
7495 7496 7497 #def fl_read_pixmapfile(win, filename, w, h, shape_mask, hotx, hoty, tran) *API change*
7498 -def fl_read_pixmapfile(win, filename, tran):
7499 """ fl_read_pixmapfile(win, filename, tran) -> pixmap, w, h, shapemask, hotx, hoty 7500 """ 7501 7502 _fl_read_pixmapfile = cfuncproto( 7503 load_so_libforms(), "fl_read_pixmapfile", 7504 Pixmap, [Window, STRING, cty.POINTER(cty.c_uint), 7505 cty.POINTER(cty.c_uint), cty.POINTER(Pixmap), 7506 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), FL_COLOR], 7507 """Pixmap fl_read_pixmapfile(Window win, const char * file, 7508 unsigned int * w, unsigned int * h, Pixmap * shape_mask, 7509 int * hotx, int * hoty, FL_COLOR tran) 7510 """) 7511 check_admitted_listvalues(tran, COLOR_list) 7512 ulwin = convert_to_Window(win) 7513 sfilename = convert_to_string(filename) 7514 ultran = convert_to_FL_COLOR(tran) 7515 w, pw = make_uint_and_pointer() 7516 h, ph = make_uint_and_pointer() 7517 shapemask, pshapemask = make_ulong_and_pointer() 7518 hotx, photx = make_int_and_pointer() 7519 hoty, photy = make_int_and_pointer() 7520 keep_elem_refs(win, filename, w, h, shapemask, hotx, hoty, tran, ulwin, 7521 sfilename, ultran, pw, ph, pshapemask, photx, photy) 7522 retval = _fl_read_pixmapfile(ulwin, sfilename, pw, ph, pshapemask, \ 7523 photx, photy, ultran) 7524 return retval, w, h, shapemask, hotx, hoty
7525 7526
7527 -def fl_create_from_pixmapdata(win, data, w, h, sm, hotx, hoty, tran):
7528 """ fl_create_from_pixmapdata(win, data, w, h, sm, hotx, hoty, tran) -> pixmap 7529 """ 7530 7531 _fl_create_from_pixmapdata = cfuncproto( 7532 load_so_libforms(), "fl_create_from_pixmapdata", 7533 Pixmap, [Window, cty.POINTER(STRING), cty.POINTER(cty.c_uint), 7534 cty.POINTER(cty.c_uint), cty.POINTER(Pixmap), 7535 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), FL_COLOR], 7536 """Pixmap fl_create_from_pixmapdata(Window win, char * * data, 7537 unsigned int * w, unsigned int * h, Pixmap * sm, int * hotx, 7538 int * hoty, FL_COLOR tran) 7539 """) 7540 check_admitted_listvalues(tran, COLOR_list) 7541 ulwin = convert_to_Window(win) 7542 ultran = convert_to_FL_COLOR(tran) 7543 keep_elem_refs(win, data, w, h, sm, hotx, hoty, tran, ulwin, ultran) 7544 retval = _fl_create_from_pixmapdata(ulwin, data, w, h, sm, hotx, hoty, 7545 ultran) 7546 return retval
7547 7548
7549 -def fl_free_pixmap(idnum):
7550 """ fl_free_pixmap(idnum) 7551 7552 @param idnum : Pixmap id to be freed 7553 """ 7554 7555 _fl_free_pixmap = cfuncproto( 7556 load_so_libforms(), "fl_free_pixmap", 7557 None, [Pixmap], 7558 """void fl_free_pixmap(Pixmap id) 7559 """) 7560 ulidnum = convert_to_Pixmap(idnum) 7561 keep_elem_refs(idnum, ulidnum) 7562 _fl_free_pixmap(ulidnum)
7563 7564 7565 ################## 7566 # forms.h (box.h) 7567 ################## 7568
7569 -def fl_create_box(boxtype, x, y, w, h, label):
7570 """ 7571 fl_create_box(boxtype, x, y, w, h, label) -> pObject 7572 7573 Creates a box object. 7574 7575 @param boxtype : type of the box to be created 7576 @param x : horizontal position of box (upper-left corner) 7577 @param y : vertical position of box (upper-left corner) 7578 @param w : width of box in pixel 7579 @param h : height of box in pixel 7580 @param label : text label of box 7581 """ 7582 7583 _fl_create_box = cfuncproto( 7584 load_so_libforms(), "fl_create_box", 7585 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7586 FL_Coord, STRING], 7587 """FL_OBJECT * fl_create_box(int type, FL_Coord x, FL_Coord y, 7588 FL_Coord w, FL_Coord h, const char * label) 7589 """) 7590 check_admitted_listvalues(boxtype, BOXTYPE_list) 7591 iboxtype = convert_to_int(boxtype) 7592 ix = convert_to_FL_Coord(x) 7593 iy = convert_to_FL_Coord(y) 7594 iw = convert_to_FL_Coord(w) 7595 ih = convert_to_FL_Coord(h) 7596 slabel = convert_to_string(label) 7597 keep_elem_refs(boxtype, x, y, w, h, label, iboxtype, ix, iy, iw, 7598 ih, slabel) 7599 retval = _fl_create_box(iboxtype, ix, iy, iw, ih, slabel) 7600 return retval
7601 7602
7603 -def fl_add_box(boxtype, x, y, w, h, label):
7604 """ 7605 fl_add_box(boxtype, x, y, w, h, label) -> pObject 7606 7607 Adds a box object. 7608 7609 @param boxtype : type of the box to be added 7610 @param x : horizontal position of box (upper-left corner) 7611 @param y : vertical position of box (upper-left corner) 7612 @param w : width of box in pixel 7613 @param h : height of box in pixel 7614 @param label : text label of box 7615 """ 7616 7617 _fl_add_box = cfuncproto( 7618 load_so_libforms(), "fl_add_box", 7619 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7620 FL_Coord, STRING], 7621 """FL_OBJECT * fl_add_box(int type, FL_Coord x, FL_Coord y, 7622 FL_Coord w, FL_Coord h, const char * label) 7623 """) 7624 check_admitted_listvalues(boxtype, BOXTYPE_list) 7625 iboxtype = convert_to_int(boxtype) 7626 ix = convert_to_FL_Coord(x) 7627 iy = convert_to_FL_Coord(y) 7628 iw = convert_to_FL_Coord(w) 7629 ih = convert_to_FL_Coord(h) 7630 slabel = convert_to_string(label) 7631 keep_elem_refs(boxtype, x, y, w, h, label, iboxtype, ix, iy, iw, 7632 ih, slabel) 7633 retval = _fl_add_box(iboxtype, ix, iy, iw, ih, slabel) 7634 return retval
7635 7636 7637 7638 ####################### 7639 # forms.h (browser.h) 7640 # Object class Browser 7641 ####################### 7642 7643 # Routines 7644
7645 -def fl_create_browser(browsertype, x, y, w, h, label):
7646 """ 7647 fl_create_browser(browsertype, x, y, w, h, label) -> pObject 7648 7649 Creates a browser object. 7650 7651 @param browsertype : type of the browser to be created 7652 @param x : horizontal position of browser (upper-left corner) 7653 @param y : vertical position of browser (upper-left corner) 7654 @param w : width of browser in pixel 7655 @param h : height of browser in pixel 7656 @param label : text label of browser 7657 """ 7658 7659 _fl_create_browser = cfuncproto( 7660 load_so_libforms(), "fl_create_browser", 7661 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7662 FL_Coord, STRING], 7663 """FL_OBJECT * fl_create_browser(int type, FL_Coord x, FL_Coord y, 7664 FL_Coord w, FL_Coord h, const char * label) 7665 """) 7666 check_admitted_listvalues(browsertype, BROWSERTYPE_list) 7667 ibrowsertype = convert_to_int(browsertype) 7668 ix = convert_to_FL_Coord(x) 7669 iy = convert_to_FL_Coord(y) 7670 iw = convert_to_FL_Coord(w) 7671 ih = convert_to_FL_Coord(h) 7672 slabel = convert_to_string(label) 7673 keep_elem_refs(browsertype, x, y, w, h, label, ibrowsertype, ix, iy, iw, 7674 ih, slabel) 7675 retval = _fl_create_browser(ibrowsertype, ix, iy, iw, ih, slabel) 7676 return retval
7677 7678
7679 -def fl_add_browser(browsertype, x, y, w, h, label):
7680 """ 7681 fl_add_browser(browsertype, x, y, w, h, label) -> pObject 7682 7683 Adds a browser object. 7684 7685 @param browsertype : type of the browser to be added 7686 @param x : horizontal position of browser (upper-left corner) 7687 @param y : vertical position of browser (upper-left corner) 7688 @param w : width of browser in pixels 7689 @param h : height of browser in pixels 7690 @param label : text label of browser 7691 """ 7692 7693 _fl_add_browser = cfuncproto( 7694 load_so_libforms(), "fl_add_browser", 7695 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7696 FL_Coord, STRING], 7697 """FL_OBJECT * fl_add_browser(int type, FL_Coord x, FL_Coord y, 7698 FL_Coord w, FL_Coord h, const char * label) 7699 """) 7700 check_admitted_listvalues(browsertype, BROWSERTYPE_list) 7701 ibrowsertype = convert_to_int(browsertype) 7702 ix = convert_to_FL_Coord(x) 7703 iy = convert_to_FL_Coord(y) 7704 iw = convert_to_FL_Coord(w) 7705 ih = convert_to_FL_Coord(h) 7706 slabel = convert_to_string(label) 7707 keep_elem_refs(browsertype, x, y, w, h, label, ibrowsertype, ix, iy, iw, 7708 ih, slabel) 7709 retval = _fl_add_browser(ibrowsertype, ix, iy, iw, ih, slabel) 7710 return retval
7711 7712
7713 -def fl_clear_browser(pObject):
7714 """ 7715 fl_clear_browser(pObject) 7716 7717 Clears browser object's contents. 7718 7719 @param pObject : poiter to browser object 7720 """ 7721 7722 _fl_clear_browser = cfuncproto( 7723 load_so_libforms(), "fl_clear_browser", 7724 None, [cty.POINTER(FL_OBJECT)], 7725 """void fl_clear_browser(FL_OBJECT * ob) 7726 """) 7727 keep_elem_refs(pObject) 7728 _fl_clear_browser(pObject)
7729 7730
7731 -def fl_add_browser_line(pObject, newtext):
7732 """ 7733 fl_add_browser_line(pObject, newtext) 7734 7735 Add a line to a browser object. 7736 7737 @param pObject : pointer to browser object 7738 @param newtext : line of text to be added 7739 """ 7740 7741 _fl_add_browser_line = cfuncproto( 7742 load_so_libforms(), "fl_add_browser_line", 7743 None, [cty.POINTER(FL_OBJECT), STRING], 7744 """void fl_add_browser_line(FL_OBJECT * ob, const char * newtext) 7745 """) 7746 snewtext = convert_to_string(newtext) 7747 keep_elem_refs(pObject, newtext, snewtext) 7748 _fl_add_browser_line(pObject, snewtext)
7749 7750
7751 -def fl_addto_browser(pObject, newtext):
7752 """ fl_addto_browser(pObject, newtext) 7753 """ 7754 7755 _fl_addto_browser = cfuncproto( 7756 load_so_libforms(), "fl_addto_browser", 7757 None, [cty.POINTER(FL_OBJECT), STRING], 7758 """void fl_addto_browser(FL_OBJECT * ob, const char * newtext) 7759 """) 7760 snewtext = convert_to_string(newtext) 7761 keep_elem_refs(pObject, newtext, snewtext) 7762 _fl_addto_browser(pObject, snewtext)
7763 7764
7765 -def fl_addto_browser_chars(pObject, browsertext):
7766 """ fl_addto_browser_chars(pObject, browsertext) 7767 """ 7768 7769 _fl_addto_browser_chars = cfuncproto( 7770 load_so_libforms(), "fl_addto_browser_chars", 7771 None, [cty.POINTER(FL_OBJECT), STRING], 7772 """void fl_addto_browser_chars(FL_OBJECT * ob, const char * str) 7773 """) 7774 sbrowsertext = convert_to_string(browsertext) 7775 keep_elem_refs(pObject, browsertext, sbrowsertext) 7776 _fl_addto_browser_chars(pObject, sbrowsertext)
7777 7778 7779 fl_append_browser = fl_addto_browser_chars 7780 7781
7782 -def fl_insert_browser_line(pObject, linenumb, newtext):
7783 """ fl_insert_browser_line(pObject, linenumb, newtext) 7784 """ 7785 7786 _fl_insert_browser_line = cfuncproto( 7787 load_so_libforms(), "fl_insert_browser_line", 7788 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 7789 """void fl_insert_browser_line(FL_OBJECT * ob, int linenumb, 7790 const char * newtext) 7791 """) 7792 ilinenumb = convert_to_int(linenumb) 7793 snewtext = convert_to_string(newtext) 7794 keep_elem_refs(pObject, linenumb, newtext, ilinenumb, snewtext) 7795 _fl_insert_browser_line(pObject, ilinenumb, snewtext)
7796 7797
7798 -def fl_delete_browser_line(pObject, linenumb):
7799 """ fl_delete_browser_line(pObject, linenumb) 7800 """ 7801 7802 _fl_delete_browser_line = cfuncproto( 7803 load_so_libforms(), "fl_delete_browser_line", 7804 None, [cty.POINTER(FL_OBJECT), cty.c_int], 7805 """void fl_delete_browser_line(FL_OBJECT * ob, int linenumb) 7806 """) 7807 ilinenumb = convert_to_int(linenumb) 7808 keep_elem_refs(pObject, linenumb, ilinenumb) 7809 _fl_delete_browser_line(pObject, ilinenumb)
7810 7811
7812 -def fl_replace_browser_line(pObject, linenumb, newtext):
7813 """ fl_replace_browser_line(pObject, linenumb, newtext) 7814 """ 7815 7816 _fl_replace_browser_line = cfuncproto( 7817 load_so_libforms(), "fl_replace_browser_line", 7818 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 7819 """void fl_replace_browser_line(FL_OBJECT * ob, int linenumb, 7820 const char * newtext) 7821 """) 7822 ilinenumb = convert_to_int(linenumb) 7823 snewtext = convert_to_string(newtext) 7824 keep_elem_refs(pObject, linenumb, newtext, ilinenumb, snewtext) 7825 _fl_replace_browser_line(pObject, ilinenumb, snewtext)
7826 7827
7828 -def fl_get_browser_line(pObject, linenumb):
7829 """ fl_get_browser_line(pObject, linenumb) -> line string 7830 """ 7831 7832 _fl_get_browser_line = cfuncproto( 7833 load_so_libforms(), "fl_get_browser_line", 7834 STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 7835 """const char * fl_get_browser_line(FL_OBJECT * ob, int linenumb) 7836 """) 7837 ilinenumb = convert_to_int(linenumb) 7838 keep_elem_refs(pObject, linenumb, ilinenumb) 7839 retval = _fl_get_browser_line(pObject, ilinenumb) 7840 return retval
7841 7842
7843 -def fl_load_browser(pObject, filename):
7844 """ fl_load_browser(pObject, filename) -> num. 7845 """ 7846 7847 _fl_load_browser = cfuncproto( 7848 load_so_libforms(), "fl_load_browser", 7849 cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 7850 """int fl_load_browser(FL_OBJECT * ob, const char * filename) 7851 """) 7852 sfilename = convert_to_string(filename) 7853 keep_elem_refs(pObject, filename, sfilename) 7854 retval = _fl_load_browser(pObject, sfilename) 7855 return retval
7856 7857
7858 -def fl_select_browser_line(pObject, line):
7859 """ fl_select_browser_line(pObject, line) 7860 """ 7861 7862 _fl_select_browser_line = cfuncproto( 7863 load_so_libforms(), "fl_select_browser_line", 7864 None, [cty.POINTER(FL_OBJECT), cty.c_int], 7865 """void fl_select_browser_line(FL_OBJECT * ob, int line) 7866 """) 7867 iline = convert_to_int(line) 7868 keep_elem_refs(pObject, line, iline) 7869 _fl_select_browser_line(pObject, iline)
7870 7871
7872 -def fl_deselect_browser_line(pObject, line):
7873 """ fl_deselect_browser_line(pObject, line) 7874 """ 7875 7876 _fl_deselect_browser_line = cfuncproto( 7877 load_so_libforms(), "fl_deselect_browser_line", 7878 None, [cty.POINTER(FL_OBJECT), cty.c_int], 7879 """void fl_deselect_browser_line(FL_OBJECT * ob, int line) 7880 """) 7881 iline = convert_to_int(line) 7882 keep_elem_refs(pObject, line, iline) 7883 _fl_deselect_browser_line(pObject, iline)
7884 7885
7886 -def fl_deselect_browser(pObject):
7887 """ fl_deselect_browser(pObject) 7888 7889 @param pObject : pointer to object 7890 """ 7891 7892 _fl_deselect_browser = cfuncproto( 7893 load_so_libforms(), "fl_deselect_browser", 7894 None, [cty.POINTER(FL_OBJECT)], 7895 """void fl_deselect_browser(FL_OBJECT * ob) 7896 """) 7897 keep_elem_refs(pObject) 7898 _fl_deselect_browser(pObject)
7899 7900
7901 -def fl_isselected_browser_line(pObject, line):
7902 """ fl_isselected_browser_line(pObject, line) -> num. 7903 """ 7904 7905 _fl_isselected_browser_line = cfuncproto( 7906 load_so_libforms(), "fl_isselected_browser_line", 7907 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 7908 """int fl_isselected_browser_line(FL_OBJECT * ob, int line) 7909 """) 7910 iline = convert_to_int(line) 7911 keep_elem_refs(pObject, line, iline) 7912 retval = _fl_isselected_browser_line(pObject, iline) 7913 return retval
7914 7915
7916 -def fl_get_browser_topline(pObject):
7917 """ fl_get_browser_topline(pObject) -> num. 7918 """ 7919 7920 _fl_get_browser_topline = cfuncproto( 7921 load_so_libforms(), "fl_get_browser_topline", 7922 cty.c_int, [cty.POINTER(FL_OBJECT)], 7923 """int fl_get_browser_topline(FL_OBJECT * ob) 7924 """) 7925 keep_elem_refs(pObject) 7926 retval = _fl_get_browser_topline(pObject) 7927 return retval
7928 7929
7930 -def fl_get_browser(pObject):
7931 """ fl_get_browser(pObject) -> num. 7932 """ 7933 7934 _fl_get_browser = cfuncproto( 7935 load_so_libforms(), "fl_get_browser", 7936 cty.c_int, [cty.POINTER(FL_OBJECT)], 7937 """int fl_get_browser(FL_OBJECT * ob) 7938 """) 7939 keep_elem_refs(pObject) 7940 retval = _fl_get_browser(pObject) 7941 return retval
7942 7943
7944 -def fl_get_browser_maxline(pObject):
7945 """ fl_get_browser_maxline(pObject) -> line num. 7946 """ 7947 7948 _fl_get_browser_maxline = cfuncproto( 7949 load_so_libforms(), "fl_get_browser_maxline", 7950 cty.c_int, [cty.POINTER(FL_OBJECT)], 7951 """int fl_get_browser_maxline(FL_OBJECT * ob) 7952 """) 7953 keep_elem_refs(pObject) 7954 retval = _fl_get_browser_maxline(pObject) 7955 return retval
7956 7957
7958 -def fl_get_browser_screenlines(pObject):
7959 """ 7960 fl_get_browser_screenlines(pObject) -> lines num. 7961 7962 Returns an approximation of the number of lines shown in the 7963 browser. 7964 7965 @param pObject : pointer to browser object 7966 """ 7967 7968 _fl_get_browser_screenlines = cfuncproto( 7969 load_so_libforms(), "fl_get_browser_screenlines", 7970 cty.c_int, [cty.POINTER(FL_OBJECT)], 7971 """int fl_get_browser_screenlines(FL_OBJECT * ob) 7972 """) 7973 keep_elem_refs(pObject) 7974 retval = _fl_get_browser_screenlines(pObject) 7975 return retval
7976 7977
7978 -def fl_set_browser_topline(pObject, line):
7979 """ 7980 fl_set_browser_topline(pObject, line) 7981 7982 Moves a line to the top of the browser. 7983 7984 @param pObject : pointer to browser object 7985 @param line : number of text line to be moved to top 7986 """ 7987 7988 _fl_set_browser_topline = cfuncproto( 7989 load_so_libforms(), "fl_set_browser_topline", 7990 None, [cty.POINTER(FL_OBJECT), cty.c_int], 7991 """void fl_set_browser_topline(FL_OBJECT * ob, int line) 7992 """) 7993 iline = convert_to_int(line) 7994 keep_elem_refs(pObject, line, iline) 7995 _fl_set_browser_topline(pObject, iline)
7996 7997
7998 -def fl_set_browser_bottomline(pObject, line):
7999 """ 8000 fl_set_browser_bottomline(pObject, line) 8001 8002 Moves a line to the bottom of the browser. 8003 8004 @param pObject : pointer to browser object 8005 @param line : number of text line to be moved to bottom 8006 """ 8007 8008 _fl_set_browser_bottomline = cfuncproto( 8009 load_so_libforms(), "fl_set_browser_bottomline", 8010 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8011 """void fl_set_browser_bottomline(FL_OBJECT * ob, int line) 8012 """) 8013 iline = convert_to_int(line) 8014 keep_elem_refs(pObject, line, iline) 8015 _fl_set_browser_bottomline(pObject, iline)
8016 8017
8018 -def fl_set_browser_fontsize(pObject, size):
8019 """ 8020 fl_set_browser_fontsize(pObject, size) 8021 8022 Sets the font size of a browser object. 8023 8024 @param pObject : pointer to browser object 8025 @param size : font size to be set 8026 """ 8027 8028 _fl_set_browser_fontsize = cfuncproto( 8029 load_so_libforms(), "fl_set_browser_fontsize", 8030 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8031 """void fl_set_browser_fontsize(FL_OBJECT * ob, int size) 8032 """) 8033 isize = convert_to_int(size) 8034 keep_elem_refs(pObject, size, isize) 8035 _fl_set_browser_fontsize(pObject, isize)
8036 8037
8038 -def fl_set_browser_fontstyle(pObject, style):
8039 """ 8040 fl_set_browser_fontstyle(pObject, style) 8041 8042 Sets the font style of a browser object. 8043 8044 @param pObject : pointer to browser object 8045 @param style : font style to be set 8046 """ 8047 8048 _fl_set_browser_fontstyle = cfuncproto( 8049 load_so_libforms(), "fl_set_browser_fontstyle", 8050 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8051 """void fl_set_browser_fontstyle(FL_OBJECT * ob, int style) 8052 """) 8053 istyle = convert_to_int(style) 8054 keep_elem_refs(pObject, style, istyle) 8055 _fl_set_browser_fontstyle(pObject, istyle)
8056 8057
8058 -def fl_set_browser_specialkey(pObject, specialkey):
8059 """ 8060 fl_set_browser_specialkey(pObject, specialkey) 8061 8062 Sets the escape key used in the text. 8063 8064 @param pObject : pointer to browser object 8065 @param specialkey : escape key to be set 8066 """ 8067 8068 _fl_set_browser_specialkey = cfuncproto( 8069 load_so_libforms(), "fl_set_browser_specialkey", 8070 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8071 """void fl_set_browser_specialkey(FL_OBJECT * ob, int specialkey) 8072 """) 8073 ispecialkey = convert_to_int(specialkey) 8074 keep_elem_refs(pObject, specialkey, ispecialkey) 8075 _fl_set_browser_specialkey(pObject, ispecialkey)
8076 8077
8078 -def fl_set_browser_vscrollbar(pObject, on):
8079 """ fl_set_browser_vscrollbar(pObject, on) 8080 """ 8081 8082 _fl_set_browser_vscrollbar = cfuncproto( 8083 load_so_libforms(), "fl_set_browser_vscrollbar", 8084 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8085 """void fl_set_browser_vscrollbar(FL_OBJECT * ob, int on) 8086 """) 8087 ion = convert_to_int(on) 8088 keep_elem_refs(pObject, on, ion) 8089 _fl_set_browser_vscrollbar(pObject, ion)
8090 8091
8092 -def fl_set_browser_hscrollbar(pObject, on):
8093 """ fl_set_browser_hscrollbar(pObject, on) 8094 """ 8095 8096 _fl_set_browser_hscrollbar = cfuncproto( 8097 load_so_libforms(), "fl_set_browser_hscrollbar", 8098 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8099 """void fl_set_browser_hscrollbar(FL_OBJECT * ob, int on) 8100 """) 8101 ion = convert_to_int(on) 8102 keep_elem_refs(pObject, on, ion) 8103 _fl_set_browser_hscrollbar(pObject, ion)
8104 8105
8106 -def fl_set_browser_line_selectable(pObject, line, flag):
8107 """ fl_set_browser_line_selectable(pObject, line, flag) 8108 """ 8109 8110 _fl_set_browser_line_selectable = cfuncproto( 8111 load_so_libforms(), "fl_set_browser_line_selectable", 8112 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 8113 """void fl_set_browser_line_selectable(FL_OBJECT * ob, int line, 8114 int flag) 8115 """) 8116 iline = convert_to_int(line) 8117 iflag = convert_to_int(flag) 8118 keep_elem_refs(pObject, line, flag, iline, iflag) 8119 _fl_set_browser_line_selectable(pObject, iline, iflag)
8120 8121 8122 #def fl_get_browser_dimension(pObject, x, y, w, h) *API change*
8123 -def fl_get_browser_dimension(pObject):
8124 """ 8125 fl_get_browser_dimension(pObject) -> hor.xpos, ver.ypos, width, height 8126 8127 Returns all dimensions of a browser object. 8128 8129 @param pObject : pointer to browser object 8130 """ 8131 8132 _fl_get_browser_dimension = cfuncproto( 8133 load_so_libforms(), "fl_get_browser_dimension", 8134 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 8135 cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 8136 cty.POINTER(FL_Coord)], 8137 """void fl_get_browser_dimension(FL_OBJECT * ob, FL_Coord * x, 8138 FL_Coord * y, FL_Coord * w, FL_Coord * h) 8139 """) 8140 x, px = make_FL_Coord_and_pointer() 8141 y, py = make_FL_Coord_and_pointer() 8142 w, pw = make_FL_Coord_and_pointer() 8143 h, ph = make_FL_Coord_and_pointer() 8144 keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 8145 _fl_get_browser_dimension(pObject, px, py, pw, ph) 8146 return x, y, w, h
8147 8148
8149 -def fl_set_browser_dblclick_callback(pObject, py_CallbackPtr, argum):
8150 """ fl_set_browser_dblclick_callback(pObject, py_CallbackPtr, argum) 8151 """ 8152 8153 _fl_set_browser_dblclick_callback = cfuncproto( 8154 load_so_libforms(), "fl_set_browser_dblclick_callback", 8155 None, [cty.POINTER(FL_OBJECT), FL_CALLBACKPTR, cty.c_long], 8156 """void fl_set_browser_dblclick_callback(FL_OBJECT * ob, 8157 FL_CALLBACKPTR cb, long int a) 8158 """) 8159 largum = convert_to_long(argum) 8160 c_CallbackPtr = FL_CALLBACKPTR(py_CallbackPtr) 8161 keep_cfunc_refs(c_CallbackPtr, py_CallbackPtr) 8162 keep_elem_refs(pObject, argum, largum) 8163 _fl_set_browser_dblclick_callback(pObject, c_CallbackPtr, largum)
8164 8165
8166 -def fl_get_browser_xoffset(pObject):
8167 """ fl_get_browser_xoffset(pObject) -> coord num. 8168 8169 @param pObject : pointer to browser object 8170 """ 8171 8172 _fl_get_browser_xoffset = cfuncproto( 8173 load_so_libforms(), "fl_get_browser_xoffset", 8174 FL_Coord, [cty.POINTER(FL_OBJECT)], 8175 """FL_Coord fl_get_browser_xoffset(FL_OBJECT * ob) 8176 """) 8177 keep_elem_refs(pObject) 8178 retval = _fl_get_browser_xoffset(pObject) 8179 return retval
8180 8181
8182 -def fl_get_browser_rel_xoffset(pObject):
8183 """ fl_get_browser_rel_xoffset(pObject) -> num. 8184 8185 @param pObject : pointer to browser object 8186 """ 8187 8188 _fl_get_browser_rel_xoffset = cfuncproto( 8189 load_so_libforms(), "fl_get_browser_rel_xoffset", 8190 cty.c_double, [cty.POINTER(FL_OBJECT)], 8191 """double fl_get_browser_rel_xoffset(FL_OBJECT * ob) 8192 """) 8193 keep_elem_refs(pObject) 8194 retval = _fl_get_browser_rel_xoffset(pObject) 8195 return retval
8196 8197
8198 -def fl_set_browser_xoffset(pObject, npixels):
8199 """ fl_set_browser_xoffset(pObject, npixels) 8200 """ 8201 8202 _fl_set_browser_xoffset = cfuncproto( 8203 load_so_libforms(), "fl_set_browser_xoffset", 8204 None, [cty.POINTER(FL_OBJECT), FL_Coord], 8205 """void fl_set_browser_xoffset(FL_OBJECT * ob, FL_Coord npixels) 8206 """) 8207 inpixels = convert_to_FL_Coord(npixels) 8208 keep_elem_refs(pObject, npixels, inpixels) 8209 _fl_set_browser_xoffset(pObject, inpixels)
8210 8211
8212 -def fl_set_browser_rel_xoffset(pObject, val):
8213 """ fl_set_browser_rel_xoffset(pObject, val) 8214 """ 8215 8216 _fl_set_browser_rel_xoffset = cfuncproto( 8217 load_so_libforms(), "fl_set_browser_rel_xoffset", 8218 None, [cty.POINTER(FL_OBJECT), cty.c_double], 8219 """void fl_set_browser_rel_xoffset(FL_OBJECT * ob, double val) 8220 """) 8221 fval = convert_to_double(val) 8222 keep_elem_refs(pObject, val, fval) 8223 _fl_set_browser_rel_xoffset(pObject, fval)
8224 8225
8226 -def fl_get_browser_yoffset(pObject):
8227 """ fl_get_browser_yoffset(pObject) -> coord num. 8228 """ 8229 8230 _fl_get_browser_yoffset = cfuncproto( 8231 load_so_libforms(), "fl_get_browser_yoffset", 8232 FL_Coord, [cty.POINTER(FL_OBJECT)], 8233 """FL_Coord fl_get_browser_yoffset(FL_OBJECT * ob) 8234 """) 8235 keep_elem_refs(pObject) 8236 retval = _fl_get_browser_yoffset(pObject) 8237 return retval
8238 8239
8240 -def fl_get_browser_rel_yoffset(pObject):
8241 """ fl_get_browser_rel_yoffset(pObject) -> num. 8242 """ 8243 8244 _fl_get_browser_rel_yoffset = cfuncproto( 8245 load_so_libforms(), "fl_get_browser_rel_yoffset", 8246 cty.c_double, [cty.POINTER(FL_OBJECT)], 8247 """double fl_get_browser_rel_yoffset(FL_OBJECT * ob) 8248 """) 8249 keep_elem_refs(pObject) 8250 retval = _fl_get_browser_rel_yoffset(pObject) 8251 return retval
8252 8253
8254 -def fl_set_browser_yoffset(pObject, npixels):
8255 """ fl_set_browser_yoffset(pObject, npixels) 8256 """ 8257 8258 _fl_set_browser_yoffset = cfuncproto( 8259 load_so_libforms(), "fl_set_browser_yoffset", 8260 None, [cty.POINTER(FL_OBJECT), FL_Coord], 8261 """void fl_set_browser_yoffset(FL_OBJECT * ob, FL_Coord npixels) 8262 """) 8263 inpixels = convert_to_FL_Coord(npixels) 8264 keep_elem_refs(pObject, npixels, inpixels) 8265 _fl_set_browser_yoffset(pObject, inpixels)
8266 8267
8268 -def fl_set_browser_rel_yoffset(pObject, val):
8269 """ fl_set_browser_rel_yoffset(pObject, val) 8270 """ 8271 8272 _fl_set_browser_rel_yoffset = cfuncproto( 8273 load_so_libforms(), "fl_set_browser_rel_yoffset", 8274 None, [cty.POINTER(FL_OBJECT), cty.c_double], 8275 """void fl_set_browser_rel_yoffset(FL_OBJECT * ob, double val) 8276 """) 8277 fval = convert_to_double(val) 8278 keep_elem_refs(pObject, val, fval) 8279 _fl_set_browser_rel_yoffset(pObject, fval)
8280 8281
8282 -def fl_set_browser_scrollbarsize(pObject, hh, vw):
8283 """ fl_set_browser_scrollbarsize(pObject, hh, vw) 8284 """ 8285 8286 _fl_set_browser_scrollbarsize = cfuncproto( 8287 load_so_libforms(), "fl_set_browser_scrollbarsize", 8288 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 8289 """void fl_set_browser_scrollbarsize(FL_OBJECT * ob, 8290 int hh, int vw) 8291 """) 8292 ihh = convert_to_int(hh) 8293 ivw = convert_to_int(vw) 8294 keep_elem_refs(pObject, hh, vw, ihh, ivw) 8295 _fl_set_browser_scrollbarsize(pObject, ihh, ivw)
8296 8297
8298 -def fl_show_browser_line(pObject, line):
8299 """ 8300 fl_show_browser_line(pObject, line) 8301 8302 Bring a browser line into view. 8303 8304 @param pObject : pointer to browser object 8305 @param line : line to show 8306 """ 8307 8308 _fl_show_browser_line = cfuncproto( 8309 load_so_libforms(), "fl_show_browser_line", 8310 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8311 """void fl_show_browser_line(FL_OBJECT * ob, int j) 8312 """) 8313 iline = convert_to_int(line) 8314 keep_elem_refs(pObject, line, iline) 8315 _fl_show_browser_line(pObject, iline)
8316 8317
8318 -def fl_set_default_browser_maxlinelength(n):
8319 """ 8320 fl_set_default_browser_maxlinelength(n) -> length num. 8321 8322 Inactive function. Returns always 0 8323 8324 @param n : unused parameter 8325 """ 8326 8327 _fl_set_default_browser_maxlinelength = cfuncproto( 8328 load_so_libforms(), "fl_set_default_browser_maxlinelength", 8329 cty.c_int, [cty.c_int], 8330 """int fl_set_default_browser_maxlinelength(int n): 8331 """) 8332 inum = convert_to_int(n) 8333 keep_elem_refs(n, inum) 8334 retval = _fl_set_default_browser_maxlinelength(inum) 8335 return retval
8336 8337 8338 FL_BROWSER_SCROLL_CALLBACK = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), 8339 cty.c_int, cty.c_void_p) 8340
8341 -def fl_set_browser_hscroll_callback(pObject, py_BrowserScrollCallback, data):
8342 """ 8343 fl_set_browser_hscroll_callback(pObject, py_BrowserScrollCallback, 8344 data) 8345 8346 @param pObject : pointer to browser object 8347 @param py_BrowserScrollCallback : python function, fn(pObject, num, 8348 data) 8349 @param data : user data argument 8350 """ 8351 8352 _fl_set_browser_hscroll_callback = cfuncproto( 8353 load_so_libforms(), "fl_set_browser_hscroll_callback", 8354 None, [cty.POINTER(FL_OBJECT), FL_BROWSER_SCROLL_CALLBACK, 8355 cty.c_void_p], 8356 """void fl_set_browser_hscroll_callback(FL_OBJECT * ob, 8357 FL_BROWSER_SCROLL_CALLBACK cb, void * data) 8358 """) 8359 c_BrowserScrollCallback = FL_BROWSER_SCROLL_CALLBACK( \ 8360 py_BrowserScrollCallback) 8361 pdata = cty.cast(data, cty.c_void_p) 8362 keep_cfunc_refs(c_BrowserScrollCallback, py_BrowserScrollCallback) 8363 keep_elem_refs(pObject, data, pdata) 8364 _fl_set_browser_hscroll_callback(pObject, c_BrowserScrollCallback, pdata)
8365 8366
8367 -def fl_set_browser_vscroll_callback(pObject, py_BrowserScrollCallback, data):
8368 """ 8369 fl_set_browser_vscroll_callback(pObject, py_BrowserScrollCallback, 8370 data) 8371 8372 @param pObject : pointer to browser object 8373 @param py_BrowserScrollCallback : python function, fn(pObject, num, 8374 data) 8375 @param data : user data argument 8376 """ 8377 8378 _fl_set_browser_vscroll_callback = cfuncproto( 8379 load_so_libforms(), "fl_set_browser_vscroll_callback", 8380 None, [cty.POINTER(FL_OBJECT), FL_BROWSER_SCROLL_CALLBACK, 8381 cty.c_void_p], 8382 """void fl_set_browser_vscroll_callback(FL_OBJECT * ob, 8383 FL_BROWSER_SCROLL_CALLBACK cb, void * data) 8384 """) 8385 c_BrowserScrollCallback = FL_BROWSER_SCROLL_CALLBACK( \ 8386 py_BrowserScrollCallback) 8387 pdata = cty.cast(data, cty.c_void_p) 8388 keep_cfunc_refs(c_BrowserScrollCallback, py_BrowserScrollCallback) 8389 keep_elem_refs(pObject, data, pdata) 8390 _fl_set_browser_vscroll_callback(pObject, c_BrowserScrollCallback, pdata)
8391 8392
8393 -def fl_get_browser_line_yoffset(pObject, line):
8394 """ fl_get_browser_line_yoffset(pObject, line) -> num. 8395 """ 8396 8397 _fl_get_browser_line_yoffset = cfuncproto( 8398 load_so_libforms(), "fl_get_browser_line_yoffset", 8399 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 8400 """int fl_get_browser_line_yoffset(FL_OBJECT * obj, int line) 8401 """) 8402 iline = convert_to_int(line) 8403 keep_elem_refs(pObject, line, iline) 8404 retval = _fl_get_browser_line_yoffset(pObject, iline) 8405 return retval
8406 8407
8408 -def fl_get_browser_hscroll_callback(pObject):
8409 """ fl_get_browser_hscroll_callback(pObject) -> callback 8410 """ 8411 8412 _fl_get_browser_hscroll_callback = cfuncproto( 8413 load_so_libforms(), "fl_get_browser_hscroll_callback", 8414 FL_BROWSER_SCROLL_CALLBACK, [cty.POINTER(FL_OBJECT)], 8415 """FL_BROWSER_SCROLL_CALLBACK fl_get_browser_hscroll_callback( 8416 FL_OBJECT * ob) 8417 """) 8418 keep_elem_refs(pObject) 8419 retval = _fl_get_browser_hscroll_callback(pObject) 8420 return retval
8421 8422
8423 -def fl_get_browser_vscroll_callback(pObject):
8424 """ fl_get_browser_vscroll_callback(pObject) -> callback 8425 """ 8426 8427 _fl_get_browser_vscroll_callback = cfuncproto( 8428 load_so_libforms(), "fl_get_browser_vscroll_callback", 8429 FL_BROWSER_SCROLL_CALLBACK, [cty.POINTER(FL_OBJECT)], 8430 """FL_BROWSER_SCROLL_CALLBACK fl_get_browser_vscroll_callback( 8431 FL_OBJECT * ob) 8432 """) 8433 keep_elem_refs(pObject) 8434 retval = _fl_get_browser_vscroll_callback(pObject) 8435 return retval
8436 8437 8438 8439 ############################################################# 8440 # forms.h (button.h) 8441 # All Buttons: regular button, light button and round button 8442 ############################################################# 8443 8444 # Routines 8445
8446 -def fl_create_button(buttontype, x, y, w, h, label):
8447 """ fl_create_button(buttontype, x, y, w, h, label) -> pObject 8448 8449 Creates a button object. 8450 8451 @param buttontype : type of button object to be created 8452 @param x : horizontal position of button (upper-left corner) 8453 @param x : vertical position of button (upper-left corner) 8454 @param w : width of button in pixels 8455 @param h : height of button in pixels 8456 @param label : text label of button 8457 """ 8458 8459 _fl_create_button = cfuncproto( 8460 load_so_libforms(), "fl_create_button", 8461 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8462 FL_Coord, STRING], 8463 """FL_OBJECT * fl_create_button(int type, FL_Coord x, FL_Coord y, 8464 FL_Coord w, FL_Coord h, const char * label) 8465 """) 8466 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8467 ibuttontype = convert_to_int(buttontype) 8468 ix = convert_to_FL_Coord(x) 8469 iy = convert_to_FL_Coord(y) 8470 iw = convert_to_FL_Coord(w) 8471 ih = convert_to_FL_Coord(h) 8472 slabel = convert_to_string(label) 8473 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8474 ih, slabel) 8475 retval = _fl_create_button(ibuttontype, ix, iy, iw, ih, slabel) 8476 return retval
8477 8478
8479 -def fl_create_roundbutton(buttontype, x, y, w, h, label):
8480 """ 8481 fl_create_roundbutton(buttontype, x, y, w, h, label) -> pObject 8482 8483 @param buttontype : type of button object to be created 8484 @param x : horizontal position of button (upper-left corner) 8485 @param x : vertical position of button (upper-left corner) 8486 @param w : width of button in pixels 8487 @param h : height of button in pixels 8488 @param label : text label of button 8489 """ 8490 8491 _fl_create_roundbutton = cfuncproto( 8492 load_so_libforms(), "fl_create_roundbutton", 8493 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8494 FL_Coord, STRING], 8495 """FL_OBJECT * fl_create_roundbutton(int type, FL_Coord x, 8496 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8497 """) 8498 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8499 ibuttontype = convert_to_int(buttontype) 8500 ix = convert_to_FL_Coord(x) 8501 iy = convert_to_FL_Coord(y) 8502 iw = convert_to_FL_Coord(w) 8503 ih = convert_to_FL_Coord(h) 8504 slabel = convert_to_string(label) 8505 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8506 ih, slabel) 8507 retval = _fl_create_roundbutton(ibuttontype, ix, iy, iw, ih, slabel) 8508 return retval
8509 8510
8511 -def fl_create_round3dbutton(buttontype, x, y, w, h, label):
8512 """ 8513 fl_create_round3dbutton(buttontype, x, y, w, h, label) -> pObject 8514 8515 @param buttontype : type of button object to be created 8516 @param x : horizontal position of button (upper-left corner) 8517 @param x : vertical position of button (upper-left corner) 8518 @param w : width of button in pixels 8519 @param h : height of button in pixels 8520 @param label : text label of button 8521 """ 8522 8523 _fl_create_round3dbutton = cfuncproto( 8524 load_so_libforms(), "fl_create_round3dbutton", 8525 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8526 FL_Coord, STRING], 8527 """FL_OBJECT * fl_create_round3dbutton(int type, FL_Coord x, 8528 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8529 """) 8530 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8531 ibuttontype = convert_to_int(buttontype) 8532 ix = convert_to_FL_Coord(x) 8533 iy = convert_to_FL_Coord(y) 8534 iw = convert_to_FL_Coord(w) 8535 ih = convert_to_FL_Coord(h) 8536 slabel = convert_to_string(label) 8537 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8538 ih, slabel) 8539 retval = _fl_create_round3dbutton(ibuttontype, ix, iy, iw, ih, slabel) 8540 return retval
8541 8542
8543 -def fl_create_lightbutton(buttontype, x, y, w, h, label):
8544 """ 8545 fl_create_lightbutton(buttontype, x, y, w, h, label) -> pObject 8546 8547 @param buttontype : type of button object to be created 8548 @param x : horizontal position of button (upper-left corner) 8549 @param x : vertical position of button (upper-left corner) 8550 @param w : width of button in pixels 8551 @param h : height of button in pixels 8552 @param label : text label of button 8553 """ 8554 8555 _fl_create_lightbutton = cfuncproto( 8556 load_so_libforms(), "fl_create_lightbutton", 8557 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8558 FL_Coord, STRING], 8559 """FL_OBJECT * fl_create_lightbutton(int type, FL_Coord x, 8560 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8561 """) 8562 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8563 ibuttontype = convert_to_int(buttontype) 8564 ix = convert_to_FL_Coord(x) 8565 iy = convert_to_FL_Coord(y) 8566 iw = convert_to_FL_Coord(w) 8567 ih = convert_to_FL_Coord(h) 8568 slabel = convert_to_string(label) 8569 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8570 ih, slabel) 8571 retval = _fl_create_lightbutton(ibuttontype, ix, iy, iw, ih, slabel) 8572 return retval
8573 8574
8575 -def fl_create_checkbutton(buttontype, x, y, w, h, label):
8576 """ 8577 fl_create_checkbutton(buttontype, x, y, w, h, label) -> pObject 8578 8579 Creates a checkbutton object. 8580 8581 @param buttontype : type of button object to be created 8582 @param x : horizontal position of button (upper-left corner) 8583 @param x : vertical position of button (upper-left corner) 8584 @param w : width of button in pixels 8585 @param h : height of button in pixels 8586 @param label : text label of button 8587 """ 8588 8589 _fl_create_checkbutton = cfuncproto( 8590 load_so_libforms(), "fl_create_checkbutton", 8591 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8592 FL_Coord, STRING], 8593 """FL_OBJECT * fl_create_checkbutton(int type, FL_Coord x, 8594 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8595 """) 8596 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8597 ibuttontype = convert_to_int(buttontype) 8598 ix = convert_to_FL_Coord(x) 8599 iy = convert_to_FL_Coord(y) 8600 iw = convert_to_FL_Coord(w) 8601 ih = convert_to_FL_Coord(h) 8602 slabel = convert_to_string(label) 8603 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8604 ih, slabel) 8605 retval = _fl_create_checkbutton(ibuttontype, ix, iy, iw, ih, slabel) 8606 return retval
8607 8608
8609 -def fl_create_bitmapbutton(buttontype, x, y, w, h, label):
8610 """ 8611 fl_create_bitmapbutton(buttontype, x, y, w, h, label) -> pObject 8612 8613 @param buttontype : type of button object to be created 8614 @param x : horizontal position of button (upper-left corner) 8615 @param x : vertical position of button (upper-left corner) 8616 @param w : width of button in pixels 8617 @param h : height of button in pixels 8618 @param label : text label of button 8619 """ 8620 8621 _fl_create_bitmapbutton = cfuncproto( 8622 load_so_libforms(), "fl_create_bitmapbutton", 8623 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8624 FL_Coord, STRING], 8625 """FL_OBJECT * fl_create_bitmapbutton(int type, FL_Coord x, 8626 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8627 """) 8628 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8629 ibuttontype = convert_to_int(buttontype) 8630 ix = convert_to_FL_Coord(x) 8631 iy = convert_to_FL_Coord(y) 8632 iw = convert_to_FL_Coord(w) 8633 ih = convert_to_FL_Coord(h) 8634 slabel = convert_to_string(label) 8635 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8636 ih, slabel) 8637 retval = _fl_create_bitmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 8638 return retval
8639 8640
8641 -def fl_create_pixmapbutton(buttontype, x, y, w, h, label):
8642 """ 8643 fl_create_pixmapbutton(buttontype, x, y, w, h, label) -> pObject 8644 8645 @param buttontype : type of button object to be created 8646 @param x : horizontal position of button (upper-left corner) 8647 @param x : vertical position of button (upper-left corner) 8648 @param w : width of button in pixels 8649 @param h : height of button in pixels 8650 @param label : text label of button 8651 """ 8652 8653 _fl_create_pixmapbutton = cfuncproto( 8654 load_so_libforms(), "fl_create_pixmapbutton", 8655 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8656 FL_Coord, STRING], 8657 """FL_OBJECT * fl_create_pixmapbutton(int type, FL_Coord x, 8658 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8659 """) 8660 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8661 ibuttontype = convert_to_int(buttontype) 8662 ix = convert_to_FL_Coord(x) 8663 iy = convert_to_FL_Coord(y) 8664 iw = convert_to_FL_Coord(w) 8665 ih = convert_to_FL_Coord(h) 8666 slabel = convert_to_string(label) 8667 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8668 ih, slabel) 8669 retval = _fl_create_pixmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 8670 return retval
8671 8672
8673 -def fl_create_scrollbutton(buttontype, x, y, w, h, label):
8674 """ 8675 fl_create_scrollbutton(buttontype, x, y, w, h, label) -> pObject 8676 8677 @param buttontype : type of button object to be created 8678 @param x : horizontal position of button (upper-left corner) 8679 @param x : vertical position of button (upper-left corner) 8680 @param w : width of button in pixels 8681 @param h : height of button in pixels 8682 @param label : text label of button 8683 """ 8684 8685 _fl_create_scrollbutton = cfuncproto( 8686 load_so_libforms(), "fl_create_scrollbutton", 8687 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8688 FL_Coord, STRING], 8689 """FL_OBJECT * fl_create_scrollbutton(int type, FL_Coord x, 8690 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8691 """) 8692 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8693 ibuttontype = convert_to_int(buttontype) 8694 ix = convert_to_FL_Coord(x) 8695 iy = convert_to_FL_Coord(y) 8696 iw = convert_to_FL_Coord(w) 8697 ih = convert_to_FL_Coord(h) 8698 slabel = convert_to_string(label) 8699 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8700 ih, slabel) 8701 retval = _fl_create_scrollbutton(ibuttontype, ix, iy, iw, ih, slabel) 8702 return retval
8703 8704
8705 -def fl_create_labelbutton(buttontype, x, y, w, h, label):
8706 """ 8707 fl_create_labelbutton(buttontype, x, y, w, h, label) -> pObject 8708 8709 @param buttontype : type of button object to be created 8710 @param x : horizontal position of button (upper-left corner) 8711 @param x : vertical position of button (upper-left corner) 8712 @param w : width of button in pixels 8713 @param h : height of button in pixels 8714 @param label : text label of button 8715 """ 8716 8717 _fl_create_labelbutton = cfuncproto( 8718 load_so_libforms(), "fl_create_labelbutton", 8719 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8720 FL_Coord, STRING], 8721 """FL_OBJECT * fl_create_labelbutton(int type, FL_Coord x, 8722 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8723 """) 8724 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8725 ibuttontype = convert_to_int(buttontype) 8726 ix = convert_to_FL_Coord(x) 8727 iy = convert_to_FL_Coord(y) 8728 iw = convert_to_FL_Coord(w) 8729 ih = convert_to_FL_Coord(h) 8730 slabel = convert_to_string(label) 8731 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8732 ih, slabel) 8733 retval = _fl_create_labelbutton(ibuttontype, ix, iy, iw, ih, slabel) 8734 return retval
8735 8736
8737 -def fl_add_roundbutton(buttontype, x, y, w, h, label):
8738 """ 8739 fl_add_roundbutton(buttontype, x, y, w, h, label) -> pObject 8740 8741 @param buttontype : type of button object to be added 8742 @param x : horizontal position of button (upper-left corner) 8743 @param x : vertical position of button (upper-left corner) 8744 @param w : width of button in pixels 8745 @param h : height of button in pixels 8746 @param label : text label of button 8747 """ 8748 8749 _fl_add_roundbutton = cfuncproto( 8750 load_so_libforms(), "fl_add_roundbutton", 8751 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8752 FL_Coord, STRING], 8753 """FL_OBJECT * fl_add_roundbutton(int type, FL_Coord x, 8754 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8755 """) 8756 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8757 ibuttontype = convert_to_int(buttontype) 8758 ix = convert_to_FL_Coord(x) 8759 iy = convert_to_FL_Coord(y) 8760 iw = convert_to_FL_Coord(w) 8761 ih = convert_to_FL_Coord(h) 8762 slabel = convert_to_string(label) 8763 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8764 ih, slabel) 8765 retval = _fl_add_roundbutton(ibuttontype, ix, iy, iw, ih, slabel) 8766 return retval
8767 8768
8769 -def fl_add_round3dbutton(buttontype, x, y, w, h, label):
8770 """ 8771 fl_add_round3dbutton(buttontype, x, y, w, h, label) -> pObject 8772 8773 @param buttontype : type of button object to be added 8774 @param x : horizontal position of button (upper-left corner) 8775 @param x : vertical position of button (upper-left corner) 8776 @param w : width of button in pixels 8777 @param h : height of button in pixels 8778 @param label : text label of button 8779 """ 8780 8781 _fl_add_round3dbutton = cfuncproto( 8782 load_so_libforms(), "fl_add_round3dbutton", 8783 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8784 FL_Coord, STRING], 8785 """FL_OBJECT * fl_add_round3dbutton(int type, FL_Coord x, 8786 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8787 """) 8788 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8789 ibuttontype = convert_to_int(buttontype) 8790 ix = convert_to_FL_Coord(x) 8791 iy = convert_to_FL_Coord(y) 8792 iw = convert_to_FL_Coord(w) 8793 ih = convert_to_FL_Coord(h) 8794 slabel = convert_to_string(label) 8795 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8796 ih, slabel) 8797 retval = _fl_add_round3dbutton(ibuttontype, ix, iy, iw, ih, slabel) 8798 return retval
8799 8800
8801 -def fl_add_lightbutton(buttontype, x, y, w, h, label):
8802 """ 8803 fl_add_lightbutton(buttontype, x, y, w, h, label) -> pObject 8804 8805 @param buttontype : type of button object to be added 8806 @param x : horizontal position of button (upper-left corner) 8807 @param x : vertical position of button (upper-left corner) 8808 @param w : width of button in pixels 8809 @param h : height of button in pixels 8810 @param label : text label of button 8811 """ 8812 8813 _fl_add_lightbutton = cfuncproto( 8814 load_so_libforms(), "fl_add_lightbutton", 8815 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8816 FL_Coord, STRING], 8817 """FL_OBJECT * fl_add_lightbutton(int type, FL_Coord x, FL_Coord y, 8818 FL_Coord w, FL_Coord h, const char * label) 8819 """) 8820 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8821 ibuttontype = convert_to_int(buttontype) 8822 ix = convert_to_FL_Coord(x) 8823 iy = convert_to_FL_Coord(y) 8824 iw = convert_to_FL_Coord(w) 8825 ih = convert_to_FL_Coord(h) 8826 slabel = convert_to_string(label) 8827 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8828 ih, slabel) 8829 retval = _fl_add_lightbutton(ibuttontype, ix, iy, iw, ih, slabel) 8830 return retval
8831 8832
8833 -def fl_add_checkbutton(buttontype, x, y, w, h, label):
8834 """ 8835 fl_add_checkbutton(buttontype, x, y, w, h, label) -> pObject 8836 8837 Adds a checkbutton object. 8838 8839 @param buttontype : type of button object to be added 8840 @param x : horizontal position of button (upper-left corner) 8841 @param x : vertical position of button (upper-left corner) 8842 @param w : width of button in pixels 8843 @param h : height of button in pixels 8844 @param label : text label of button 8845 """ 8846 8847 _fl_add_checkbutton = cfuncproto( 8848 load_so_libforms(), "fl_add_checkbutton", 8849 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8850 FL_Coord, STRING], 8851 """FL_OBJECT * fl_add_checkbutton(int type, FL_Coord x, FL_Coord y, 8852 FL_Coord w, FL_Coord h, const char * label) 8853 """) 8854 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8855 ibuttontype = convert_to_int(buttontype) 8856 ix = convert_to_FL_Coord(x) 8857 iy = convert_to_FL_Coord(y) 8858 iw = convert_to_FL_Coord(w) 8859 ih = convert_to_FL_Coord(h) 8860 slabel = convert_to_string(label) 8861 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8862 ih, slabel) 8863 retval = _fl_add_checkbutton(ibuttontype, ix, iy, iw, ih, slabel) 8864 return retval
8865 8866
8867 -def fl_add_button(buttontype, x, y, w, h, label):
8868 """ 8869 fl_add_button(buttontype, x, y, w, h, label) -> pObject 8870 8871 Adds a button to the current form. 8872 8873 @param buttontype : type of button object to be added 8874 @param x : horizontal position of button (upper-left corner) 8875 @param x : vertical position of button (upper-left corner) 8876 @param w : width of button in pixels 8877 @param h : height of button in pixels 8878 @param label : text label of button 8879 """ 8880 8881 _fl_add_button = cfuncproto( 8882 load_so_libforms(), "fl_add_button", 8883 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8884 FL_Coord, STRING], 8885 """FL_OBJECT * fl_add_button(int type, FL_Coord x, FL_Coord y, 8886 FL_Coord w, FL_Coord h, const char * label) 8887 """) 8888 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8889 ibuttontype = convert_to_int(buttontype) 8890 ix = convert_to_FL_Coord(x) 8891 iy = convert_to_FL_Coord(y) 8892 iw = convert_to_FL_Coord(w) 8893 ih = convert_to_FL_Coord(h) 8894 slabel = convert_to_string(label) 8895 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8896 ih, slabel) 8897 retval = _fl_add_button(ibuttontype, ix, iy, iw, ih, slabel) 8898 return retval
8899 8900
8901 -def fl_add_bitmapbutton(buttontype, x, y, w, h, label):
8902 """ 8903 fl_add_bitmapbutton(buttontype, x, y, w, h, label) -> pObject 8904 8905 @param buttontype : type of button object to be added 8906 @param x : horizontal position of button (upper-left corner) 8907 @param x : vertical position of button (upper-left corner) 8908 @param w : width of button in pixels 8909 @param h : height of button in pixels 8910 @param label : text label of button 8911 """ 8912 8913 _fl_add_bitmapbutton = cfuncproto( 8914 load_so_libforms(), "fl_add_bitmapbutton", 8915 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8916 FL_Coord, STRING], 8917 """FL_OBJECT * fl_add_bitmapbutton(int type, FL_Coord x, 8918 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8919 """) 8920 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8921 ibuttontype = convert_to_int(buttontype) 8922 ix = convert_to_FL_Coord(x) 8923 iy = convert_to_FL_Coord(y) 8924 iw = convert_to_FL_Coord(w) 8925 ih = convert_to_FL_Coord(h) 8926 slabel = convert_to_string(label) 8927 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8928 ih, slabel) 8929 retval = _fl_add_bitmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 8930 return retval
8931 8932
8933 -def fl_add_scrollbutton(buttontype, x, y, w, h, label):
8934 """ 8935 fl_add_scrollbutton(buttontype, x, y, w, h, label) -> pObject 8936 8937 @param buttontype : type of button object to be added 8938 @param x : horizontal position of button (upper-left corner) 8939 @param x : vertical position of button (upper-left corner) 8940 @param w : width of button in pixels 8941 @param h : height of button in pixels 8942 @param label : text label of button 8943 """ 8944 8945 _fl_add_scrollbutton = cfuncproto( 8946 load_so_libforms(), "fl_add_scrollbutton", 8947 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8948 FL_Coord, STRING], 8949 """FL_OBJECT * fl_add_scrollbutton(int type, FL_Coord x, 8950 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8951 """) 8952 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8953 ibuttontype = convert_to_int(buttontype) 8954 ix = convert_to_FL_Coord(x) 8955 iy = convert_to_FL_Coord(y) 8956 iw = convert_to_FL_Coord(w) 8957 ih = convert_to_FL_Coord(h) 8958 slabel = convert_to_string(label) 8959 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8960 ih, slabel) 8961 retval = _fl_add_scrollbutton(ibuttontype, ix, iy, iw, ih, slabel) 8962 return retval
8963 8964
8965 -def fl_add_labelbutton(buttontype, x, y, w, h, label):
8966 """ 8967 fl_add_labelbutton(buttontype, x, y, w, h, label) -> pObject 8968 8969 @param buttontype : type of button object to be added 8970 @param x : horizontal position of button (upper-left corner) 8971 @param x : vertical position of button (upper-left corner) 8972 @param w : width of button in pixels 8973 @param h : height of button in pixels 8974 @param label : text label of button 8975 """ 8976 8977 _fl_add_labelbutton = cfuncproto( 8978 load_so_libforms(), "fl_add_labelbutton", 8979 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8980 FL_Coord, STRING], 8981 """FL_OBJECT * fl_add_labelbutton(int type, FL_Coord x, 8982 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8983 """) 8984 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8985 ibuttontype = convert_to_int(buttontype) 8986 ix = convert_to_FL_Coord(x) 8987 iy = convert_to_FL_Coord(y) 8988 iw = convert_to_FL_Coord(w) 8989 ih = convert_to_FL_Coord(h) 8990 slabel = convert_to_string(label) 8991 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8992 ih, slabel) 8993 retval = _fl_add_labelbutton(ibuttontype, ix, iy, iw, ih, slabel) 8994 return retval
8995 8996 8997 fl_set_bitmapbutton_file = fl_set_bitmap_file 8998 8999
9000 -def fl_set_bitmapbutton_data(pObject, w, h, bits):
9001 """ fl_set_bitmapbutton_data(pObject, w, h, bits) 9002 """ 9003 9004 _fl_set_bitmapbutton_data = cfuncproto( 9005 load_so_libforms(), "fl_set_bitmapbutton_data", 9006 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 9007 cty.POINTER(cty.c_ubyte)], 9008 """void fl_set_bitmapbutton_data(FL_OBJECT * ob, int w, int h, 9009 unsigned char * bits) 9010 """) 9011 iw = convert_to_int(w) 9012 ih = convert_to_int(h) 9013 pbits = cty.cast(bits, cty.POINTER(cty.c_ubyte)) 9014 keep_elem_refs(pObject, w, h, bits, iw, ih, pbits) 9015 _fl_set_bitmapbutton_data(pObject, iw, ih, pbits)
9016 9017 9018 fl_set_bitmapbutton_datafile = fl_set_bitmapbutton_file 9019 9020
9021 -def fl_add_pixmapbutton(buttontype, x, y, w, h, label):
9022 """ 9023 fl_add_pixmapbutton(buttontype, x, y, w, h, label) -> pObject 9024 9025 @param buttontype : type of button object to be added 9026 @param x : horizontal position of button (upper-left corner) 9027 @param x : vertical position of button (upper-left corner) 9028 @param w : width of button in pixels 9029 @param h : height of button in pixels 9030 @param label : text label of button 9031 """ 9032 9033 _fl_add_pixmapbutton = cfuncproto( 9034 load_so_libforms(), "fl_add_pixmapbutton", 9035 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9036 FL_Coord, STRING], 9037 """FL_OBJECT * fl_add_pixmapbutton(int type, FL_Coord x, 9038 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 9039 """) 9040 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 9041 ibuttontype = convert_to_int(buttontype) 9042 ix = convert_to_FL_Coord(x) 9043 iy = convert_to_FL_Coord(y) 9044 iw = convert_to_FL_Coord(w) 9045 ih = convert_to_FL_Coord(h) 9046 slabel = convert_to_string(label) 9047 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 9048 ih, slabel) 9049 retval = _fl_add_pixmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 9050 return retval
9051 9052
9053 -def fl_set_pixmapbutton_focus_outline(pObject, yes):
9054 """ fl_set_pixmapbutton_focus_outline(pObject, yes) 9055 """ 9056 9057 _fl_set_pixmapbutton_focus_outline = cfuncproto( 9058 load_so_libforms(), "fl_set_pixmapbutton_focus_outline", 9059 None, [cty.POINTER(FL_OBJECT), cty.c_int], 9060 """void fl_set_pixmapbutton_focus_outline(FL_OBJECT * ob, int yes) 9061 """) 9062 iyes = convert_to_int(yes) 9063 keep_elem_refs(pObject, yes, iyes) 9064 _fl_set_pixmapbutton_focus_outline(pObject, iyes)
9065 9066 9067 fl_set_pixmapbutton_data = fl_set_pixmap_data 9068 fl_set_pixmapbutton_file = fl_set_pixmap_file 9069 fl_set_pixmapbutton_pixmap = fl_set_pixmap_pixmap 9070 fl_get_pixmapbutton_pixmap = fl_get_pixmap_pixmap 9071 fl_set_pixmapbutton_align = fl_set_pixmap_align 9072 fl_free_pixmapbutton_pixmap = fl_free_pixmap_pixmap 9073 fl_set_pixmapbutton_datafile = fl_set_pixmapbutton_file 9074 fl_set_pixmapbutton_show_focus = fl_set_pixmapbutton_focus_outline 9075 9076
9077 -def fl_set_pixmapbutton_focus_data(pObject, bits):
9078 """ fl_set_pixmapbutton_focus_data(pObject, bits) 9079 """ 9080 9081 _fl_set_pixmapbutton_focus_data = cfuncproto( 9082 load_so_libforms(), "fl_set_pixmapbutton_focus_data", 9083 None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING)], 9084 """void fl_set_pixmapbutton_focus_data(FL_OBJECT * ob, 9085 char * * bits) 9086 """) 9087 keep_elem_refs(pObject, bits) 9088 _fl_set_pixmapbutton_focus_data(pObject, bits)
9089 9090
9091 -def fl_set_pixmapbutton_focus_file(pObject, fname):
9092 """ fl_set_pixmapbutton_focus_file(pObject, fname) 9093 """ 9094 9095 _fl_set_pixmapbutton_focus_file = cfuncproto( 9096 load_so_libforms(), "fl_set_pixmapbutton_focus_file", 9097 None, [cty.POINTER(FL_OBJECT), STRING], 9098 """void fl_set_pixmapbutton_focus_file(FL_OBJECT * ob, 9099 const char * fname) 9100 """) 9101 sfname = convert_to_string(fname) 9102 keep_elem_refs(pObject, fname, sfname) 9103 _fl_set_pixmapbutton_focus_file(pObject, sfname)
9104 9105
9106 -def fl_set_pixmapbutton_focus_pixmap(pObject, idnum, mask):
9107 """ fl_set_pixmapbutton_focus_pixmap(pObject, idnum, mask) 9108 """ 9109 9110 _fl_set_pixmapbutton_focus_pixmap = cfuncproto( 9111 load_so_libforms(), "fl_set_pixmapbutton_focus_pixmap", 9112 None, [cty.POINTER(FL_OBJECT), Pixmap, Pixmap], 9113 """void fl_set_pixmapbutton_focus_pixmap(FL_OBJECT * ob, 9114 Pixmap id, Pixmap mask) 9115 """) 9116 ulidnum = convert_to_ulong(idnum) 9117 ulmask = convert_to_ulong(mask) 9118 keep_elem_refs(pObject, idnum, mask, ulidnum, ulmask) 9119 _fl_set_pixmapbutton_focus_pixmap(pObject, ulidnum, ulmask)
9120 9121
9122 -def fl_get_button(pObject):
9123 """ 9124 fl_get_button(pObject) -> num. 9125 9126 Returns the value of the button. 9127 9128 @param pObject : pointer to button object 9129 """ 9130 9131 _fl_get_button = cfuncproto( 9132 load_so_libforms(), "fl_get_button", 9133 cty.c_int, [cty.POINTER(FL_OBJECT)], 9134 """int fl_get_button(FL_OBJECT * ob) 9135 """) 9136 keep_elem_refs(pObject) 9137 retval = _fl_get_button(pObject) 9138 return retval
9139 9140
9141 -def fl_set_button(pObject, pushed):
9142 """ 9143 fl_set_button(pObject, pushed) 9144 9145 Sets the button state (not pushed/pushed). 9146 9147 @param pObject : pointer to button object 9148 @param pushed : state of button to be set (0|1) 9149 """ 9150 9151 _fl_set_button = cfuncproto( 9152 load_so_libforms(), "fl_set_button", 9153 None, [cty.POINTER(FL_OBJECT), cty.c_int], 9154 """void fl_set_button(FL_OBJECT * ob, int pushed) 9155 """) 9156 ipushed = convert_to_int(pushed) 9157 keep_elem_refs(pObject, pushed, ipushed) 9158 _fl_set_button(pObject, ipushed)
9159 9160
9161 -def fl_get_button_numb(pObject):
9162 """ 9163 fl_get_button_numb(pObject) -> num. 9164 9165 Returns the number of the last used mouse button. fl_mouse_button 9166 will also return the mouse number. 9167 9168 @param pObject : pointer to button object 9169 """ 9170 9171 _fl_get_button_numb = cfuncproto( 9172 load_so_libforms(), "fl_get_button_numb", 9173 cty.c_int, [cty.POINTER(FL_OBJECT)], 9174 """int fl_get_button_numb(FL_OBJECT * ob) 9175 """) 9176 keep_elem_refs(pObject) 9177 retval = _fl_get_button_numb(pObject) 9178 return retval
9179 9180 9181 fl_set_button_shortcut = fl_set_object_shortcut 9182 9183
9184 -def fl_create_generic_button(objclass, buttontype, x, y, w, h, label):
9185 """ 9186 fl_create_generic_button(objclass, buttontype, x, y, w, h, label) -> pObject 9187 9188 Creates a generic button object. 9189 9190 @param objclass : value of a new button class 9191 @param buttontype : type of button object to be created 9192 @param x : horizontal position of button (upper-left corner) 9193 @param x : vertical position of button (upper-left corner) 9194 @param w : width of button in pixels 9195 @param h : height of button in pixels 9196 @param label : text label of button 9197 """ 9198 9199 _fl_create_generic_button = cfuncproto( 9200 load_so_libforms(), "fl_create_generic_button", 9201 cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord, FL_Coord, 9202 FL_Coord, FL_Coord, STRING], 9203 """FL_OBJECT * fl_create_generic_button(int objclass, int type, 9204 FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, 9205 const char * label) 9206 """) 9207 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 9208 iobjclass = convert_to_int(objclass) 9209 ibuttontype = convert_to_int(buttontype) 9210 ix = convert_to_FL_Coord(x) 9211 iy = convert_to_FL_Coord(y) 9212 iw = convert_to_FL_Coord(w) 9213 ih = convert_to_FL_Coord(h) 9214 slabel = convert_to_string(label) 9215 keep_elem_refs(objclass, buttontype, x, y, w, h, label, iobjclass, 9216 ibuttontype, ix, iy, iw, ih, slabel) 9217 retval = _fl_create_generic_button(iobjclass, ibuttontype, ix, iy, 9218 iw, ih, slabel) 9219 return retval
9220 9221 9222 FL_DrawButton = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT)) 9223 FL_CleanupButton = cty.CFUNCTYPE(None, cty.POINTER(FL_BUTTON_SPEC)) 9224 9225 FL_DRAWBUTTON = FL_DrawButton 9226 FL_CLEANUPBUTTON = FL_CleanupButton 9227
9228 -def fl_add_button_class(bclass, py_DrawButton, py_CleanupButton):
9229 """ 9230 fl_add_button_class(bclass, py_DrawButton, py_CleanupButton) 9231 9232 Associates a button class with a drawing function. 9233 9234 @param bclass : value of a new button class 9235 @param py_DrawButton : python function to draw button, fn(pObject) 9236 @param py_CleanupButton : python function to cleanup button, 9237 fn(pButtonSpec) 9238 """ 9239 9240 _fl_add_button_class = cfuncproto( 9241 load_so_libforms(), "fl_add_button_class", 9242 None, [cty.c_int, FL_DrawButton, FL_CleanupButton], 9243 """void fl_add_button_class(int bclass, FL_DrawButton drawit, 9244 FL_CleanupButton cleanup) 9245 """) 9246 ibclass = convert_to_int(bclass) 9247 c_DrawButton = FL_DrawButton(py_DrawButton) 9248 c_CleanupButton = FL_CleanupButton(py_CleanupButton) 9249 keep_cfunc_refs(c_DrawButton, py_DrawButton, c_CleanupButton, 9250 py_CleanupButton) 9251 keep_elem_refs(bclass, ibclass) 9252 _fl_add_button_class(ibclass, c_DrawButton, c_CleanupButton)
9253 9254
9255 -def fl_set_button_mouse_buttons(pObject, buttons):
9256 """ 9257 fl_set_button_mouse_buttons(pObject, buttons) 9258 9259 Function allows to set up to which mouse buttons the button object 9260 will react. 9261 9262 @param pObject : pointer to button object 9263 @param buttons : value of mouse buttons to be set 9264 """ 9265 9266 _fl_set_button_mouse_buttons = cfuncproto( 9267 load_so_libforms(), "fl_set_button_mouse_buttons", 9268 None, [cty.POINTER(FL_OBJECT), cty.c_uint], 9269 """void fl_set_button_mouse_buttons(FL_OBJECT * ob, 9270 unsigned int buttons) 9271 """) 9272 ibuttons = convert_to_int(buttons) 9273 keep_elem_refs(pObject, buttons, ibuttons) 9274 _fl_set_button_mouse_buttons(pObject, ibuttons)
9275 9276 9277 #def fl_get_button_mouse_buttons(pObject, buttons) *API change*
9278 -def fl_get_button_mouse_buttons(pObject):
9279 """ 9280 fl_get_button_mouse_buttons(pObject) -> buttons value 9281 9282 Returns a value indicating which mouse buttons the button object 9283 will react to. 9284 9285 @param pObject : pointer to button object 9286 """ 9287 9288 _fl_get_button_mouse_buttons = cfuncproto( 9289 load_so_libforms(), "fl_get_button_mouse_buttons", 9290 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint)], 9291 """void fl_get_button_mouse_buttons(FL_OBJECT * ob, 9292 unsigned int * buttons) 9293 """) 9294 buttons, pbuttons = make_uint_and_pointer() 9295 keep_elem_refs(pObject, buttons, pbuttons) 9296 _fl_get_button_mouse_buttons(pObject, pbuttons) 9297 return buttons
9298 9299 9300 ####################### 9301 # forms.h (canvas.h) 9302 # Header for FL_CANVAS 9303 ####################### 9304 9305 # Interfaces 9306
9307 -def fl_create_generic_canvas(canvasclass, canvastype, x, y, w, h, label):
9308 """ 9309 fl_create_generic_canvas(canvasclass, canvastype, x, y, w, h, label) -> pObject 9310 9311 Creates a generic canvas object. 9312 9313 @param canvasclass : value of a new canvas class 9314 @param canvastype : type of canvas object to be created 9315 @param x : horizontal position of canvas (upper-left corner) 9316 @param x : vertical position of canvas (upper-left corner) 9317 @param w : width of canvas in pixels 9318 @param h : height of canvas in pixels 9319 @param label : text label of canvas 9320 """ 9321 9322 _fl_create_generic_canvas = cfuncproto( 9323 load_so_libforms(), "fl_create_generic_canvas", 9324 cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord, FL_Coord, 9325 FL_Coord, FL_Coord, STRING], 9326 """FL_OBJECT * fl_create_generic_canvas(int canvas_class, 9327 int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, 9328 const char * label) 9329 """) 9330 check_admitted_listvalues(canvastype, CANVASTYPE_list) 9331 icanvasclass = convert_to_int(canvasclass) 9332 icanvastype = convert_to_int(canvastype) 9333 ix = convert_to_FL_Coord(x) 9334 iy = convert_to_FL_Coord(y) 9335 iw = convert_to_FL_Coord(w) 9336 ih = convert_to_FL_Coord(h) 9337 slabel = convert_to_string(label) 9338 keep_elem_refs(canvasclass, canvastype, x, y, w, h, label, icanvasclass, 9339 icanvastype, ix, iy, iw, ih, slabel) 9340 retval = _fl_create_generic_canvas(icanvasclass, icanvastype, ix, iy, iw, ih, 9341 slabel) 9342 return retval
9343 9344
9345 -def fl_add_canvas(canvastype, x, y, w, h, label):
9346 """ 9347 fl_add_canvas(canvastype, x, y, w, h, label) -> pObject 9348 9349 Adds a canvas object. 9350 9351 @param canvastype : type of canvas object to be added 9352 @param x : horizontal position of canvas (upper-left corner) 9353 @param x : vertical position of canvas (upper-left corner) 9354 @param w : width of canvas in pixels 9355 @param h : height of canvas in pixels 9356 @param label : text label of canvas 9357 """ 9358 9359 _fl_add_canvas = cfuncproto( 9360 load_so_libforms(), "fl_add_canvas", 9361 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9362 FL_Coord, STRING], 9363 """FL_OBJECT * fl_add_canvas(int type, FL_Coord x, FL_Coord y, 9364 FL_Coord w, FL_Coord h, const char * label) 9365 """) 9366 check_admitted_listvalues(canvastype, CANVASTYPE_list) 9367 icanvastype = convert_to_int(canvastype) 9368 ix = convert_to_FL_Coord(x) 9369 iy = convert_to_FL_Coord(y) 9370 iw = convert_to_FL_Coord(w) 9371 ih = convert_to_FL_Coord(h) 9372 slabel = convert_to_string(label) 9373 keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 9374 iw, ih, slabel) 9375 retval = _fl_add_canvas(icanvastype, ix, iy, iw, ih, slabel) 9376 return retval
9377 9378
9379 -def fl_create_canvas(canvastype, x, y, w, h, label):
9380 """ 9381 fl_create_canvas(canvastype, x, y, w, h, label) -> pObject 9382 9383 Creates a canvas object. 9384 9385 @param canvastype : type of canvas object to be created 9386 @param x : horizontal position of canvas (upper-left corner) 9387 @param x : vertical position of canvas (upper-left corner) 9388 @param w : width of canvas in pixels 9389 @param h : height of canvas in pixels 9390 @param label : text label of canvas 9391 """ 9392 9393 _fl_create_canvas = cfuncproto( 9394 load_so_libforms(), "fl_create_canvas", 9395 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9396 FL_Coord, STRING], 9397 """FL_OBJECT * fl_create_canvas(int type, FL_Coord x, FL_Coord y, 9398 FL_Coord w, FL_Coord h, const char * label) 9399 """) 9400 check_admitted_listvalues(canvastype, CANVASTYPE_list) 9401 icanvastype = convert_to_int(canvastype) 9402 ix = convert_to_FL_Coord(x) 9403 iy = convert_to_FL_Coord(y) 9404 iw = convert_to_FL_Coord(w) 9405 ih = convert_to_FL_Coord(h) 9406 slabel = convert_to_string(label) 9407 keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 9408 iw, ih, slabel) 9409 retval = _fl_create_canvas(icanvastype, ix, iy, iw, ih, slabel) 9410 return retval
9411 9412 9413 # backward compatibility 9414 fl_set_canvas_decoration = fl_set_object_boxtype 9415 9416
9417 -def fl_set_canvas_colormap(pObject, colormap):
9418 """ fl_set_canvas_colormap(pObject, colormap) 9419 """ 9420 9421 _fl_set_canvas_colormap = cfuncproto( 9422 load_so_libforms(), "fl_set_canvas_colormap", 9423 None, [cty.POINTER(FL_OBJECT), Colormap], 9424 """void fl_set_canvas_colormap(FL_OBJECT * ob, Colormap colormap) 9425 """) 9426 ulcolormap = convert_to_ulong(colormap) 9427 keep_elem_refs(pObject, colormap, ulcolormap) 9428 _fl_set_canvas_colormap(pObject, ulcolormap)
9429 9430
9431 -def fl_set_canvas_visual(pObject, vi):
9432 """ fl_set_canvas_visual(pObject, vi) 9433 """ 9434 9435 _fl_set_canvas_visual = cfuncproto( 9436 load_so_libforms(), "fl_set_canvas_visual", 9437 None, [cty.POINTER(FL_OBJECT), cty.POINTER(Visual)], 9438 """void fl_set_canvas_visual(FL_OBJECT * obj, Visual * vi) 9439 """) 9440 keep_elem_refs(pObject, vi) 9441 _fl_set_canvas_visual(pObject, vi)
9442 9443
9444 -def fl_set_canvas_depth(pObject, depth):
9445 """ fl_set_canvas_depth(pObject, depth) 9446 """ 9447 9448 _fl_set_canvas_depth = cfuncproto( 9449 load_so_libforms(), "fl_set_canvas_depth", 9450 None, [cty.POINTER(FL_OBJECT), cty.c_int], 9451 """void fl_set_canvas_depth(FL_OBJECT * obj, int depth) 9452 """) 9453 idepth = convert_to_int(depth) 9454 keep_elem_refs(pObject, depth, idepth) 9455 _fl_set_canvas_depth(pObject, idepth)
9456 9457
9458 -def fl_set_canvas_attributes(pObject, mask, pXSetWindowAttributes):
9459 """ fl_set_canvas_attributes(pObject, mask, pXSetWindowAttributes) 9460 """ 9461 9462 _fl_set_canvas_attributes = cfuncproto( 9463 load_so_libforms(), "fl_set_canvas_attributes", 9464 None, [cty.POINTER(FL_OBJECT), cty.c_uint, 9465 cty.POINTER(XSetWindowAttributes)], 9466 """void fl_set_canvas_attributes(FL_OBJECT * ob, 9467 unsigned int mask, XSetWindowAttributes * xswa) 9468 """) 9469 uimask = convert_to_uint(mask) 9470 keep_elem_refs(pObject, mask, pXSetWindowAttributes, uimask) 9471 _fl_set_canvas_attributes(pObject, uimask, pXSetWindowAttributes)
9472 9473 9474 FL_HANDLE_CANVAS = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), Window, 9475 cty.c_int, cty.c_int, cty.POINTER(XEvent), cty.c_void_p) 9476
9477 -def fl_add_canvas_handler(pObject, ev, py_HandleCanvas, udata):
9478 """ fl_add_canvas_handler(pObject, ev, py_HandleCanvas, udata) -> canvas handler 9479 """ 9480 9481 _fl_add_canvas_handler = cfuncproto( 9482 load_so_libforms(), "fl_add_canvas_handler", 9483 FL_HANDLE_CANVAS, [cty.POINTER(FL_OBJECT), cty.c_int, 9484 FL_HANDLE_CANVAS, cty.c_void_p], 9485 """FL_HANDLE_CANVAS fl_add_canvas_handler(FL_OBJECT * ob, int ev, 9486 FL_HANDLE_CANVAS h, void * udata) 9487 """) 9488 iev = convert_to_int(ev) 9489 c_HandleCanvas = FL_HANDLE_CANVAS(py_HandleCanvas) 9490 pudata = cty.cast(udata, cty.c_void_p) 9491 keep_cfunc_refs(c_HandleCanvas, py_HandleCanvas) 9492 keep_elem_refs(pObject, ev, udata, iev, pudata) 9493 retval = _fl_add_canvas_handler(pObject, iev, c_HandleCanvas, pudata) 9494 return retval
9495 9496
9497 -def fl_get_canvas_id(pObject):
9498 """ 9499 fl_get_canvas_id(pObject) -> window 9500 9501 Returns the window ID of the canvas window. 9502 9503 @param pObject : pointer to canvas object 9504 """ 9505 9506 _fl_get_canvas_id = cfuncproto( 9507 load_so_libforms(), "fl_get_canvas_id", 9508 Window, [cty.POINTER(FL_OBJECT)], 9509 """Window fl_get_canvas_id(FL_OBJECT * ob) 9510 """) 9511 keep_elem_refs(pObject) 9512 retval = _fl_get_canvas_id(pObject) 9513 return retval
9514 9515
9516 -def fl_get_canvas_colormap(pObject):
9517 """ fl_get_canvas_colormap(pObject) -> colormap 9518 """ 9519 9520 _fl_get_canvas_colormap = cfuncproto( 9521 load_so_libforms(), "fl_get_canvas_colormap", 9522 Colormap, [cty.POINTER(FL_OBJECT)], 9523 """Colormap fl_get_canvas_colormap(FL_OBJECT * ob) 9524 """) 9525 keep_elem_refs(pObject) 9526 retval = _fl_get_canvas_colormap(pObject) 9527 return retval
9528 9529
9530 -def fl_get_canvas_depth(pObject):
9531 """ fl_get_canvas_depth(pObject) -> depth num. 9532 """ 9533 9534 _fl_get_canvas_depth = cfuncproto( 9535 load_so_libforms(), "fl_get_canvas_depth", 9536 cty.c_int, [cty.POINTER(FL_OBJECT)], 9537 """int fl_get_canvas_depth(FL_OBJECT * obj) 9538 """) 9539 keep_elem_refs(pObject) 9540 retval = _fl_get_canvas_depth(pObject) 9541 return retval
9542 9543
9544 -def fl_remove_canvas_handler(pObject, ev, py_HandleCanvas):
9545 """ 9546 fl_remove_canvas_handler(pObject, ev, py_HandleCanvas) 9547 9548 Remove a particular handler for event ev. If ev is invalid, removes 9549 all handlers and their corresponding event mask. 9550 9551 @param pObject : pointer to canvas object 9552 @param ev : event number 9553 @param py_HandleCanvas : python function for canvas handler 9554 """ 9555 9556 _fl_remove_canvas_handler = cfuncproto( 9557 load_so_libforms(), "fl_remove_canvas_handler", 9558 None, [cty.POINTER(FL_OBJECT), cty.c_int, FL_HANDLE_CANVAS], 9559 """void fl_remove_canvas_handler(FL_OBJECT * ob, int ev, 9560 FL_HANDLE_CANVAS h) 9561 """) 9562 iev = convert_to_int(ev) 9563 c_HandleCanvas = FL_HANDLE_CANVAS(py_HandleCanvas) 9564 keep_cfunc_refs(c_HandleCanvas, py_HandleCanvas) 9565 keep_elem_refs(pObject, ev, iev) 9566 _fl_remove_canvas_handler(pObject, iev, c_HandleCanvas)
9567 9568
9569 -def fl_hide_canvas(pObject):
9570 """ 9571 fl_hide_canvas(pObject) 9572 9573 Hides a canvas object. 9574 9575 @param pObject : pointer to canvas object 9576 """ 9577 9578 _fl_hide_canvas = cfuncproto( 9579 load_so_libforms(), "fl_hide_canvas", 9580 None, [cty.POINTER(FL_OBJECT)], 9581 """void fl_hide_canvas(FL_OBJECT * ob) 9582 """) 9583 keep_elem_refs(pObject) 9584 _fl_hide_canvas(pObject)
9585 9586
9587 -def fl_share_canvas_colormap(pObject, colormap):
9588 """ fl_share_canvas_colormap(pObject, colormap) 9589 """ 9590 9591 _fl_share_canvas_colormap = cfuncproto( 9592 load_so_libforms(), "fl_share_canvas_colormap", 9593 None, [cty.POINTER(FL_OBJECT), Colormap], 9594 """void fl_share_canvas_colormap(FL_OBJECT * ob, Colormap colormap) 9595 """) 9596 ulcolormap = convert_to_ulong(colormap) 9597 keep_elem_refs(pObject, colormap, ulcolormap) 9598 _fl_share_canvas_colormap(pObject, ulcolormap)
9599 9600
9601 -def fl_clear_canvas(pObject):
9602 """ 9603 fl_clear_canvas(pObject) 9604 9605 Clears the canvas to the background color. If no background is 9606 defined use black. 9607 9608 @param pObject : pointer to canvas object 9609 """ 9610 9611 _fl_clear_canvas = cfuncproto( 9612 load_so_libforms(), "fl_clear_canvas", 9613 None, [cty.POINTER(FL_OBJECT)], 9614 """void fl_clear_canvas(FL_OBJECT * ob) 9615 """) 9616 keep_elem_refs(pObject) 9617 _fl_clear_canvas(pObject)
9618 9619 9620 FL_MODIFY_CANVAS_PROP = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT)) 9621
9622 -def fl_modify_canvas_prop(pObject, py_initModifyCanvasProp, \ 9623 py_activateModifyCanvasProp, py_cleanupModifyCanvasProp):
9624 """ 9625 fl_modify_canvas_prop(pObject, py_initModifyCanvasProp, \ 9626 py_activateModifyCanvasProp, py_cleanupModifyCanvasProp) 9627 9628 """ 9629 9630 _fl_modify_canvas_prop = cfuncproto( 9631 load_so_libforms(), "fl_modify_canvas_prop", 9632 None, [cty.POINTER(FL_OBJECT), FL_MODIFY_CANVAS_PROP, 9633 FL_MODIFY_CANVAS_PROP, FL_MODIFY_CANVAS_PROP], 9634 """void fl_modify_canvas_prop(FL_OBJECT * obj, 9635 FL_MODIFY_CANVAS_PROP init, FL_MODIFY_CANVAS_PROP activate, 9636 FL_MODIFY_CANVAS_PROP cleanup) 9637 """) 9638 c_initModifyCanvasProp = FL_MODIFY_CANVAS_PROP(py_initModifyCanvasProp) 9639 c_activateModifyCanvasProp = FL_MODIFY_CANVAS_PROP( \ 9640 py_activateModifyCanvasProp) 9641 c_cleanupModifyCanvasProp = FL_MODIFY_CANVAS_PROP( \ 9642 py_cleanupModifyCanvasProp) 9643 keep_cfunc_refs(c_initModifyCanvasProp, py_initModifyCanvasProp, \ 9644 c_activateModifyCanvasProp, py_activateModifyCanvasProp, \ 9645 c_cleanupModifyCanvasProp, py_cleanupModifyCanvasProp) 9646 keep_elem_refs(pObject) 9647 _fl_modify_canvas_prop(pObject, c_initModifyCanvasProp, 9648 c_activateModifyCanvasProp, c_cleanupModifyCanvasProp)
9649 9650
9651 -def fl_canvas_yield_to_shortcut(pObject, yes):
9652 """ fl_canvas_yield_to_shortcut(pObject, yes) 9653 """ 9654 9655 _fl_canvas_yield_to_shortcut = cfuncproto( 9656 load_so_libforms(), "fl_canvas_yield_to_shortcut", 9657 None, [cty.POINTER(FL_OBJECT), cty.c_int], 9658 """void fl_canvas_yield_to_shortcut(FL_OBJECT * ob, int yes) 9659 """) 9660 iyes = convert_to_int(yes) 9661 keep_elem_refs(pObject, yes, iyes) 9662 _fl_canvas_yield_to_shortcut(pObject, iyes)
9663 9664 9665 9666 ############# 9667 # glcanvas.h 9668 ############# 9669 9670 # This is an attempt to maintain some sort of backwards compatibility 9671 # with old code whilst also getting rid of the old, system-specific 9672 # hack. 9673 9674 # OpenGL canvases 9675
9676 -def fl_create_glcanvas(canvastype, x, y, w, h, label):
9677 """ fl_create_glcanvas(canvastype, x, y, w, h, label) -> pObject 9678 """ 9679 9680 _fl_create_glcanvas = cfuncproto( 9681 load_so_libformsgl(), "fl_create_glcanvas", 9682 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9683 FL_Coord, STRING], 9684 """FL_OBJECT * fl_create_glcanvas(int type, FL_Coord x, FL_Coord y, 9685 FL_Coord w, FL_Coord h, const char * label) 9686 """) 9687 check_admitted_listvalues(canvastype, CANVASTYPE_list) 9688 icanvastype = convert_to_int(canvastype) 9689 ix = convert_to_FL_Coord(x) 9690 iy = convert_to_FL_Coord(y) 9691 iw = convert_to_FL_Coord(w) 9692 ih = convert_to_FL_Coord(h) 9693 slabel = convert_to_string(label) 9694 keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 9695 iw, ih, slabel) 9696 retval = _fl_create_glcanvas(icanvastype, ix, iy, iw, ih, slabel) 9697 return retval
9698 9699
9700 -def fl_add_glcanvas(canvastype, x, y, w, h, label):
9701 """ fl_add_glcanvas(canvastype, x, y, w, h, label) -> pObject 9702 """ 9703 9704 _fl_add_glcanvas = cfuncproto( 9705 load_so_libformsgl(), "fl_add_glcanvas", 9706 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9707 FL_Coord, STRING], 9708 """FL_OBJECT * fl_add_glcanvas(int type, FL_Coord x, FL_Coord y, 9709 FL_Coord w, FL_Coord h, const char * label) 9710 """) 9711 check_admitted_listvalues(canvastype, CANVASTYPE_list) 9712 icanvastype = convert_to_int(canvastype) 9713 ix = convert_to_FL_Coord(x) 9714 iy = convert_to_FL_Coord(y) 9715 iw = convert_to_FL_Coord(w) 9716 ih = convert_to_FL_Coord(h) 9717 slabel = convert_to_string(label) 9718 keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 9719 iw, ih, slabel) 9720 retval = _fl_add_glcanvas(icanvastype, ix, iy, iw, ih, slabel) 9721 return retval
9722 9723
9724 -def fl_set_glcanvas_defaults(config):
9725 """ fl_set_glcanvas_defaults(config): 9726 """ 9727 9728 _fl_set_glcanvas_defaults = cfuncproto( 9729 load_so_libformsgl(), "fl_set_glcanvas_defaults", 9730 None, [cty.POINTER(cty.c_int)], 9731 """void fl_set_glcanvas_defaults(const int * config): 9732 """) 9733 #iconfig = convert_to_int(config) 9734 keep_elem_refs(config) #, iconfig) 9735 _fl_set_glcanvas_defaults(config)
9736 9737
9738 -def fl_get_glcanvas_defaults(config):
9739 """ fl_get_glcanvas_defaults(config): 9740 """ 9741 9742 _fl_get_glcanvas_defaults = cfuncproto( 9743 load_so_libformsgl(), "fl_get_glcanvas_defaults", 9744 None, [cty.c_int], 9745 """void fl_get_glcanvas_defaults(int config[ ]): 9746 """) 9747 iconfig = convert_to_int(config) 9748 keep_elem_refs(config, iconfig) 9749 _fl_get_glcanvas_defaults(iconfig)
9750 9751
9752 -def fl_set_glcanvas_attributes(pObject, config):
9753 """ fl_set_glcanvas_attributes(pObject, config) 9754 """ 9755 9756 _fl_set_glcanvas_attributes = cfuncproto( 9757 load_so_libformsgl(), "fl_set_glcanvas_attributes", 9758 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], 9759 """void fl_set_glcanvas_attributes(FL_OBJECT * ob, 9760 const int * config) 9761 """) 9762 keep_elem_refs(pObject, config) 9763 _fl_set_glcanvas_attributes(pObject, config)
9764 9765
9766 -def fl_get_glcanvas_attributes(pObject, attributes):
9767 """ fl_get_glcanvas_attributes(pObject, attributes) 9768 """ 9769 9770 _fl_get_glcanvas_attributes = cfuncproto( 9771 load_so_libformsgl(), "fl_get_glcanvas_attributes", 9772 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], 9773 """void fl_get_glcanvas_attributes(FL_OBJECT * ob, 9774 int * attributes) 9775 """) 9776 keep_elem_refs(pObject, attributes) 9777 _fl_get_glcanvas_attributes(pObject, attributes)
9778 9779
9780 -def fl_set_glcanvas_direct(pObject, direct):
9781 """ fl_set_glcanvas_direct(pObject, direct) 9782 """ 9783 9784 _fl_set_glcanvas_direct = cfuncproto( 9785 load_so_libformsgl(), "fl_set_glcanvas_direct", 9786 None, [cty.POINTER(FL_OBJECT), cty.c_int], 9787 """void fl_set_glcanvas_direct(FL_OBJECT * ob, int direct) 9788 """) 9789 idirect = convert_to_int(direct) 9790 keep_elem_refs(pObject, direct, idirect) 9791 _fl_set_glcanvas_direct(pObject, idirect)
9792 9793
9794 -def fl_activate_glcanvas(pObject):
9795 """ fl_activate_glcanvas(pObject) 9796 """ 9797 9798 _fl_activate_glcanvas = cfuncproto( 9799 load_so_libformsgl(), "fl_activate_glcanvas", 9800 None, [cty.POINTER(FL_OBJECT)], 9801 """void fl_activate_glcanvas(FL_OBJECT * ob) 9802 """) 9803 keep_elem_refs(pObject) 9804 _fl_activate_glcanvas(pObject)
9805 9806
9807 -def fl_get_glcanvas_xvisualinfo(pObject):
9808 """ fl_get_glcanvas_xvisualinfo(pObject) -> xvisualinfo class 9809 """ 9810 9811 _fl_get_glcanvas_xvisualinfo = cfuncproto( 9812 load_so_libformsgl(), "fl_get_glcanvas_xvisualinfo", 9813 cty.POINTER(XVisualInfo), [cty.POINTER(FL_OBJECT)], 9814 """)XVisualInfo * fl_get_glcanvas_xvisualinfo(FL_OBJECT * ob) 9815 """) 9816 keep_elem_refs(pObject) 9817 retval = _fl_get_glcanvas_xvisualinfo(pObject) 9818 return retval
9819 9820
9821 -def fl_get_glcanvas_context(pObject):
9822 """ fl_get_glcanvas_context(pObject) -> glxcontext class 9823 """ 9824 9825 _fl_get_glcanvas_context = cfuncproto( 9826 load_so_libformsgl(), "fl_get_glcanvas_context", 9827 GLXContext, [cty.POINTER(FL_OBJECT)], 9828 """)GLXContext fl_get_glcanvas_context(FL_OBJECT * ob) 9829 """) 9830 keep_elem_refs(pObject) 9831 retval = _fl_get_glcanvas_context(pObject) 9832 return retval
9833 9834
9835 -def fl_glwincreate(config, pGLXContext, w, h):
9836 """ fl_glwincreate(config, pGLXContext, w, h) -> window 9837 """ 9838 9839 _fl_glwincreate = cfuncproto( 9840 load_so_libformsgl(), "fl_glwincreate", 9841 Window, [cty.POINTER(cty.c_int), cty.POINTER(GLXContext), 9842 cty.c_int, cty.c_int], 9843 """Window fl_glwincreate(int * config, GLXContext * context, 9844 int w, int h) 9845 """) 9846 iw = convert_to_int(w) 9847 ih = convert_to_int(h) 9848 keep_elem_refs(config, pGLXContext, w, h, iw, ih) 9849 retval = _fl_glwincreate(config, pGLXContext, iw, ih) 9850 return retval
9851 9852
9853 -def fl_glwinopen(config, pGLXContext, w, h):
9854 """ fl_glwinopen(config, pGLXContext, w, h) -> window 9855 """ 9856 9857 _fl_glwinopen = cfuncproto( 9858 load_so_libformsgl(), "fl_glwinopen", 9859 Window, [cty.POINTER(cty.c_int), cty.POINTER(GLXContext), 9860 cty.c_int, cty.c_int], 9861 """Window fl_glwinopen(int * config, GLXContext * context, 9862 int w, int h 9863 """) 9864 iw = convert_to_int(w) 9865 ih = convert_to_int(h) 9866 keep_elem_refs(config, pGLXContext, w, h, iw, ih) 9867 retval = _fl_glwinopen(config, pGLXContext, iw, ih) 9868 return retval
9869 9870 9871 9872 ############################# 9873 # forms.h (chart.h) 9874 # Object Class: Chart 9875 ############################# 9876 9877 # Routines 9878
9879 -def fl_create_chart(charttype, x, y, w, h, label):
9880 """ 9881 fl_create_chart(charttype, x, y, w, h, label) -> pObject 9882 9883 Creates a chart object. 9884 9885 @param charttype : type of chart object to be created 9886 @param x : horizontal position of chart (upper-left corner) 9887 @param x : vertical position of chart (upper-left corner) 9888 @param w : width of chart in pixels 9889 @param h : height of chart in pixels 9890 @param label : text label of chart 9891 """ 9892 9893 _fl_create_chart = cfuncproto( 9894 load_so_libforms(), "fl_create_chart", 9895 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9896 FL_Coord, STRING], 9897 """FL_OBJECT * fl_create_chart(int type, FL_Coord x, FL_Coord y, 9898 FL_Coord w, FL_Coord h, const char * label) 9899 """) 9900 check_admitted_listvalues(charttype, CHARTTYPE_list) 9901 icharttype = convert_to_int(charttype) 9902 ix = convert_to_FL_Coord(x) 9903 iy = convert_to_FL_Coord(y) 9904 iw = convert_to_FL_Coord(w) 9905 ih = convert_to_FL_Coord(h) 9906 slabel = convert_to_string(label) 9907 keep_elem_refs(charttype, x, y, w, h, label, icharttype, ix, iy, 9908 iw, ih, slabel) 9909 retval = _fl_create_chart(icharttype, ix, iy, iw, ih, slabel) 9910 return retval
9911 9912
9913 -def fl_add_chart(charttype, x, y, w, h, label):
9914 """ 9915 fl_add_chart(charttype, x, y, w, h, label) -> pObject 9916 9917 Adds a chart object. 9918 9919 @param charttype : type of chart object to be created 9920 @param x : horizontal position of chart (upper-left corner) 9921 @param x : vertical position of chart (upper-left corner) 9922 @param w : width of chart in pixels 9923 @param h : height of chart in pixels 9924 @param label : text label of chart 9925 """ 9926 9927 _fl_add_chart = cfuncproto( 9928 load_so_libforms(), "fl_add_chart", 9929 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9930 FL_Coord, STRING], 9931 """FL_OBJECT * fl_add_chart(int type, FL_Coord x, FL_Coord y, 9932 FL_Coord w, FL_Coord h, const char * label) 9933 """) 9934 check_admitted_listvalues(charttype, CHARTTYPE_list) 9935 icharttype = convert_to_int(charttype) 9936 ix = convert_to_FL_Coord(x) 9937 iy = convert_to_FL_Coord(y) 9938 iw = convert_to_FL_Coord(w) 9939 ih = convert_to_FL_Coord(h) 9940 slabel = convert_to_string(label) 9941 keep_elem_refs(charttype, x, y, w, h, label, icharttype, ix, iy, 9942 iw, ih, slabel) 9943 retval = _fl_add_chart(icharttype, ix, iy, iw, ih, slabel) 9944 return retval
9945 9946
9947 -def fl_clear_chart(pObject):
9948 """ fl_clear_chart(pObject) 9949 9950 Clears the contents of a chart. 9951 9952 @param pObject : pointer to chart object 9953 """ 9954 9955 _fl_clear_chart = cfuncproto( 9956 load_so_libforms(), "fl_clear_chart", 9957 None, [cty.POINTER(FL_OBJECT)], 9958 """void fl_clear_chart(FL_OBJECT * ob) 9959 """) 9960 keep_elem_refs(pObject) 9961 _fl_clear_chart(pObject)
9962 9963
9964 -def fl_add_chart_value(pObject, val, label, col):
9965 """ 9966 fl_add_chart_value(pObject, val, label, col) 9967 9968 Adds an item to the chart. 9969 9970 @param pObject : pointer to chart object 9971 @param val : value of chart item 9972 @param label : text label of chart object 9973 @param col : ? 9974 """ 9975 9976 _fl_add_chart_value = cfuncproto( 9977 load_so_libforms(), "fl_add_chart_value", 9978 None, [cty.POINTER(FL_OBJECT), cty.c_double, STRING, cty.c_int], 9979 """void fl_add_chart_value(FL_OBJECT * ob, double val, 9980 const char * str, int col) 9981 """) 9982 fval = convert_to_double(val) 9983 slabel = convert_to_string(label) 9984 icol = convert_to_int(col) 9985 keep_elem_refs(pObject, val, label, col, fval, slabel, icol) 9986 _fl_add_chart_value(pObject, fval, slabel, icol)
9987 9988
9989 -def fl_insert_chart_value(pObject, indx, val, label, col):
9990 """ 9991 fl_insert_chart_value(pObject, indx, val, label, col) 9992 9993 Inserts an item before indx to the chart. 9994 9995 @param pObject : pointer to chart object 9996 @param indx : index position of previous item 9997 @param val : value of chart item 9998 @param label : text label of chart 9999 @param col : ? 10000 """ 10001 10002 _fl_insert_chart_value = cfuncproto( 10003 load_so_libforms(), "fl_insert_chart_value", 10004 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, STRING, 10005 cty.c_int], 10006 """void fl_insert_chart_value(FL_OBJECT * ob, int indx, 10007 double val, const char * str, int col) 10008 """) 10009 iindx = convert_to_int(indx) 10010 fval = convert_to_double(val) 10011 slabel = convert_to_string(label) 10012 icol = convert_to_int(col) 10013 keep_elem_refs(pObject, indx, val, label, col, iindx, fval, 10014 slabel, icol) 10015 _fl_insert_chart_value(pObject, iindx, fval, slabel, icol)
10016 10017
10018 -def fl_replace_chart_value(pObject, indx, val, label, col):
10019 """ 10020 fl_replace_chart_value(pObject, indx, val, label, col) 10021 10022 Replaces value in the chart. 10023 10024 @param pObject : pointer to chart object 10025 @param indx : index position of item to be replaced 10026 @param val : value of chart item 10027 @param label : text label of chart 10028 @param col : ? 10029 """ 10030 10031 _fl_replace_chart_value = cfuncproto( 10032 load_so_libforms(), "fl_replace_chart_value", 10033 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, STRING, 10034 cty.c_int], 10035 """void fl_replace_chart_value(FL_OBJECT * ob, int indx, 10036 double val, const char * str, int col) 10037 """) 10038 iindx = convert_to_int(indx) 10039 fval = convert_to_double(val) 10040 slabel = convert_to_string(label) 10041 icol = convert_to_int(col) 10042 keep_elem_refs(pObject, indx, val, label, col, iindx, fval, 10043 slabel, icol) 10044 _fl_replace_chart_value(pObject, iindx, fval, slabel, icol)
10045 10046
10047 -def fl_set_chart_bounds(pObject, minbound, maxbound):
10048 """ 10049 fl_set_chart_bounds(pObject, minbound, maxbound) 10050 10051 Sets the boundaries/limits for values of a chart object. 10052 10053 @param pObject : pointer to chart object 10054 @param minbound : minimum bounds to be set 10055 @param maxbound : maximum bounds to be set 10056 """ 10057 10058 _fl_set_chart_bounds = cfuncproto( 10059 load_so_libforms(), "fl_set_chart_bounds", 10060 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 10061 """void fl_set_chart_bounds(FL_OBJECT * ob, double min, 10062 double max) 10063 """) 10064 fminbound = convert_to_double(minbound) 10065 fmaxbound = convert_to_double(maxbound) 10066 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 10067 _fl_set_chart_bounds(pObject, fminbound, fmaxbound)
10068 10069 10070 #def fl_get_chart_bounds(pObject, minbound, maxbound) *API change*
10071 -def fl_get_chart_bounds(pObject):
10072 """ 10073 fl_get_chart_bounds(pObject) -> minbound, maxbound 10074 10075 Returns the boundaries/limits set for values of a chart object. 10076 10077 @param pObject : pointer to chart object 10078 """ 10079 10080 _fl_get_chart_bounds = cfuncproto( 10081 load_so_libforms(), "fl_get_chart_bounds", 10082 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 10083 cty.POINTER(cty.c_double)], 10084 """void fl_get_chart_bounds(FL_OBJECT * ob, double * min, 10085 double * max) 10086 """) 10087 minbound, pminbound = make_double_and_pointer() 10088 maxbound, pmaxbound = make_double_and_pointer() 10089 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 10090 _fl_get_chart_bounds(pObject, pminbound, pmaxbound) 10091 return minbound, maxbound
10092 10093
10094 -def fl_set_chart_maxnumb(pObject, maxnum):
10095 """ 10096 fl_set_chart_maxnumb(pObject, maxnum) 10097 10098 Sets the maximum number of values displayed in the chart. 10099 10100 @param pObject : pointer to chart object 10101 @param maxnum : maximum number of values to display 10102 """ 10103 10104 _fl_set_chart_maxnumb = cfuncproto( 10105 load_so_libforms(), "fl_set_chart_maxnumb", 10106 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10107 """void fl_set_chart_maxnumb(FL_OBJECT * ob, int maxnumb) 10108 """) 10109 imaxnum = convert_to_int(maxnum) 10110 keep_elem_refs(pObject, maxnum, imaxnum) 10111 _fl_set_chart_maxnumb(pObject, imaxnum)
10112 10113
10114 -def fl_set_chart_autosize(pObject, autosize):
10115 """ 10116 fl_set_chart_autosize(pObject, autosize) 10117 10118 Sets whether the chart should autosize along the x-axis. 10119 10120 @param pObject : pointer to chart object 10121 @param autosize : autosize flag is enabled/disabled (1|0) 10122 """ 10123 10124 _fl_set_chart_autosize = cfuncproto( 10125 load_so_libforms(), "fl_set_chart_autosize", 10126 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10127 """void fl_set_chart_autosize(FL_OBJECT * ob, int autosize) 10128 """) 10129 iautosize = convert_to_int(autosize) 10130 keep_elem_refs(pObject, autosize, iautosize) 10131 _fl_set_chart_autosize(pObject, iautosize)
10132 10133
10134 -def fl_set_chart_lstyle(pObject, lstyle):
10135 """ fl_set_chart_lstyle(pObject, lstyle) 10136 """ 10137 10138 _fl_set_chart_lstyle = cfuncproto( 10139 load_so_libforms(), "fl_set_chart_lstyle", 10140 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10141 """void fl_set_chart_lstyle(FL_OBJECT * ob, int lstyle) 10142 """) 10143 ilstyle = convert_to_int(lstyle) 10144 keep_elem_refs(pObject, lstyle, ilstyle) 10145 _fl_set_chart_lstyle(pObject, ilstyle)
10146 10147
10148 -def fl_set_chart_lsize(pObject, lsize):
10149 """ fl_set_chart_lsize(pObject, lsize) 10150 """ 10151 10152 _fl_set_chart_lsize = cfuncproto( 10153 load_so_libforms(), "fl_set_chart_lsize", 10154 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10155 """void fl_set_chart_lsize(FL_OBJECT * ob, int lsize) 10156 """) 10157 ilsize = convert_to_int(lsize) 10158 keep_elem_refs(pObject, lsize, ilsize) 10159 _fl_set_chart_lsize(pObject, ilsize)
10160 10161
10162 -def fl_set_chart_lcolor(pObject, colr):
10163 """ fl_set_chart_lcolor(pObject, colr) 10164 """ 10165 10166 _fl_set_chart_lcolor = cfuncproto( 10167 load_so_libforms(), "fl_set_chart_lcolor", 10168 None, [cty.POINTER(FL_OBJECT), FL_COLOR], 10169 """void fl_set_chart_lcolor(FL_OBJECT * ob, FL_COLOR lcol) 10170 """) 10171 ulcolr = convert_to_FL_COLOR(colr) 10172 keep_elem_refs(pObject, colr, ulcolr) 10173 _fl_set_chart_lcolor(pObject, ulcolr)
10174 10175
10176 -def fl_set_chart_baseline(pObject, yesno):
10177 """ fl_set_chart_baseline(pObject, yesno) 10178 """ 10179 10180 _fl_set_chart_baseline = cfuncproto( 10181 load_so_libforms(), "fl_set_chart_baseline", 10182 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10183 """void fl_set_chart_baseline(FL_OBJECT * ob, int iYesNo) 10184 """) 10185 iyesno = convert_to_int(yesno) 10186 keep_elem_refs(pObject, yesno, iyesno) 10187 _fl_set_chart_baseline(pObject, iyesno)
10188 10189 10190 fl_set_chart_lcol = fl_set_chart_lcolor 10191 10192 10193 10194 ##################### 10195 # forms.h (choice.h) 10196 ##################### 10197 10198 # Routines 10199
10200 -def fl_create_choice(choicetype, x, y, w, h, label):
10201 """ 10202 fl_create_choice(choicetype, x, y, w, h, label) -> pObject 10203 10204 Creates a choice object. 10205 10206 @param choicetype : type of choice object to be created 10207 @param x : horizontal position of choice (upper-left corner) 10208 @param x : vertical position of choice (upper-left corner) 10209 @param w : width of choice in pixels 10210 @param h : height of choice in pixels 10211 @param label : text label of choice 10212 """ 10213 10214 _fl_create_choice = cfuncproto( 10215 load_so_libforms(), "fl_create_choice", 10216 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10217 FL_Coord, STRING], 10218 """FL_OBJECT * fl_create_choice(int type, FL_Coord x, FL_Coord y, 10219 FL_Coord w, FL_Coord h, const char * label) 10220 """) 10221 check_admitted_listvalues(choicetype, CHOICETYPE_list) 10222 ichoicetype = convert_to_int(choicetype) 10223 ix = convert_to_FL_Coord(x) 10224 iy = convert_to_FL_Coord(y) 10225 iw = convert_to_FL_Coord(w) 10226 ih = convert_to_FL_Coord(h) 10227 slabel = convert_to_string(label) 10228 keep_elem_refs(choicetype, x, y, w, h, label, ichoicetype, ix, iy, 10229 iw, ih, slabel) 10230 retval = _fl_create_choice(ichoicetype, ix, iy, iw, ih, slabel) 10231 return retval
10232 10233
10234 -def fl_add_choice(choicetype, x, y, w, h, label):
10235 """ 10236 fl_add_choice(choicetype, x, y, w, h, label) -> pObject 10237 10238 Adds a choice object. 10239 10240 @param choicetype : type of choice object to be added 10241 @param x : horizontal position of choice (upper-left corner) 10242 @param x : vertical position of choice (upper-left corner) 10243 @param w : width of choice in pixels 10244 @param h : height of choice in pixels 10245 @param label : text label of choice 10246 """ 10247 10248 _fl_add_choice = cfuncproto( 10249 load_so_libforms(), "fl_add_choice", 10250 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10251 FL_Coord, STRING], 10252 """FL_OBJECT * fl_add_choice(int type, FL_Coord x, FL_Coord y, 10253 FL_Coord w, FL_Coord h, const char * label) DEPRECATED 10254 """) 10255 check_admitted_listvalues(choicetype, CHOICETYPE_list) 10256 ichoicetype = convert_to_int(choicetype) 10257 ix = convert_to_FL_Coord(x) 10258 iy = convert_to_FL_Coord(y) 10259 iw = convert_to_FL_Coord(w) 10260 ih = convert_to_FL_Coord(h) 10261 slabel = convert_to_string(label) 10262 keep_elem_refs(choicetype, x, y, w, h, label, ichoicetype, ix, iy, 10263 iw, ih, slabel) 10264 retval = _fl_add_choice(ichoicetype, ix, iy, iw, ih, slabel) 10265 return retval
10266 10267
10268 -def fl_clear_choice(pObject):
10269 """ 10270 fl_clear_choice(pObject) 10271 10272 Clears the choice object. 10273 10274 @param pObject : pointer to chioce object 10275 """ 10276 10277 _fl_clear_choice = cfuncproto( 10278 load_so_libforms(), "fl_clear_choice", 10279 None, [cty.POINTER(FL_OBJECT)], 10280 """void fl_clear_choice(FL_OBJECT * ob) DEPRECATED 10281 """) 10282 keep_elem_refs(pObject) 10283 _fl_clear_choice(pObject)
10284 10285
10286 -def fl_addto_choice(pObject, choicetxt):
10287 """ 10288 fl_addto_choice(pObject, choicetxt) -> num. 10289 10290 Adds a single or multiple (delimited by '|') item(s) to a choice. 10291 10292 @param pObject : pointer to choice object 10293 @param choicetxt : text of item(s) to be added 10294 """ 10295 10296 _fl_addto_choice = cfuncproto( 10297 load_so_libforms(), "fl_addto_choice", 10298 cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 10299 """int fl_addto_choice(FL_OBJECT * ob, const char * str) DEPRECATED 10300 """) 10301 warn_deprecated_function() 10302 schoicetxt = convert_to_string(choicetxt) 10303 keep_elem_refs(pObject, choicetxt, schoicetxt) 10304 retval = _fl_addto_choice(pObject, schoicetxt) 10305 return retval
10306 10307
10308 -def fl_replace_choice(pObject, itemnum, choicetxt):
10309 """ 10310 fl_replace_choice(pObject, itemnum, choicetxt) 10311 10312 Replaces a line to the choice item. 10313 10314 @param pObject : pointer to choice object 10315 @param itemnum : item number to be replaced 10316 @param choicetxt : text of item to replace 10317 """ 10318 10319 _fl_replace_choice = cfuncproto( 10320 load_so_libforms(), "fl_replace_choice", 10321 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 10322 """void fl_replace_choice(FL_OBJECT * ob, int numb, 10323 const char * str) DEPRECATED 10324 """) 10325 iitemnum = convert_to_int(itemnum) 10326 schoicetxt = convert_to_string(choicetxt) 10327 keep_elem_refs(pObject, itemnum, choicetxt, iitemnum, schoicetxt) 10328 _fl_replace_choice(pObject, iitemnum, schoicetxt)
10329 10330
10331 -def fl_delete_choice(pObject, itemnum):
10332 """ 10333 fl_delete_choice(pObject, itemnum) 10334 10335 Removes a line from the choice item. 10336 10337 @param pObject : pointer to choice object 10338 @param itemnum : item number 10339 """ 10340 10341 _fl_delete_choice = cfuncproto( 10342 load_so_libforms(), "fl_delete_choice", 10343 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10344 """void fl_delete_choice(FL_OBJECT * ob, int numb) DEPRECATED 10345 """) 10346 iitemnum = convert_to_int(itemnum) 10347 keep_elem_refs(pObject, itemnum, iitemnum) 10348 _fl_delete_choice(pObject, iitemnum)
10349 10350
10351 -def fl_set_choice(pObject, choice):
10352 """ 10353 fl_set_choice(pObject, choice) 10354 10355 Sets the number of the choice. 10356 10357 @param pObject : pointer to choice object 10358 @param choice : choice number 10359 """ 10360 10361 _fl_set_choice = cfuncproto( 10362 load_so_libforms(), "fl_set_choice", 10363 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10364 """void fl_set_choice(FL_OBJECT * ob, int choice) DEPRECATED 10365 """) 10366 ichoice = convert_to_int(choice) 10367 keep_elem_refs(pObject, choice, ichoice) 10368 _fl_set_choice(pObject, ichoice)
10369 10370
10371 -def fl_set_choice_text(pObject, choicetxt):
10372 """ 10373 fl_set_choice_text(pObject, choicetxt) 10374 10375 Sets the choice using choice text. 10376 10377 @param pObject : pointer to choice object 10378 @param choicetxt : text of choice 10379 """ 10380 10381 _fl_set_choice_text = cfuncproto( 10382 load_so_libforms(), "fl_set_choice_text", 10383 None, [cty.POINTER(FL_OBJECT), STRING], 10384 """void fl_set_choice_text(FL_OBJECT * ob, const char * txt) DEPRECATED 10385 """) 10386 schoicetxt = convert_to_string(choicetxt) 10387 keep_elem_refs(pObject, choicetxt, schoicetxt) 10388 _fl_set_choice_text(pObject, schoicetxt)
10389 10390
10391 -def fl_get_choice(pObject):
10392 """ 10393 fl_get_choice(pObject) -> num. 10394 10395 Returns the number of the choice. 10396 10397 @param pObject : pointer to choice object 10398 """ 10399 10400 _fl_get_choice = cfuncproto( 10401 load_so_libforms(), "fl_get_choice", 10402 cty.c_int, [cty.POINTER(FL_OBJECT)], 10403 """int fl_get_choice(FL_OBJECT * ob) DEPRECATED 10404 """) 10405 keep_elem_refs(pObject) 10406 retval = _fl_get_choice(pObject) 10407 return retval
10408 10409
10410 -def fl_get_choice_item_text(pObject, n):
10411 """ fl_get_choice_item_text(pObject, n) -> text string 10412 """ 10413 10414 _fl_get_choice_item_text = cfuncproto( 10415 load_so_libforms(), "fl_get_choice_item_text", 10416 STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 10417 """const char * fl_get_choice_item_text(FL_OBJECT * ob, int n) DEPRECATED 10418 """) 10419 inum = convert_to_int(n) 10420 keep_elem_refs(pObject, n, inum) 10421 retval = _fl_get_choice_item_text(pObject, inum) 10422 return retval
10423 10424
10425 -def fl_get_choice_maxitems(pObject):
10426 """ fl_get_choice_maxitems(pObject) -> items num. 10427 """ 10428 10429 _fl_get_choice_maxitems = cfuncproto( 10430 load_so_libforms(), "fl_get_choice_maxitems", 10431 cty.c_int, [cty.POINTER(FL_OBJECT)], 10432 """int fl_get_choice_maxitems(FL_OBJECT * ob) DEPRECATED 10433 """) 10434 keep_elem_refs(pObject) 10435 retval = _fl_get_choice_maxitems(pObject) 10436 return retval
10437 10438
10439 -def fl_get_choice_text(pObject):
10440 """ 10441 fl_get_choice_text(pObject) -> text string 10442 10443 Returns the text of the choice. 10444 10445 @param pObject : pointer to choice object 10446 """ 10447 10448 _fl_get_choice_text = cfuncproto( 10449 load_so_libforms(), "fl_get_choice_text", 10450 STRING, [cty.POINTER(FL_OBJECT)], 10451 """const char * fl_get_choice_text(FL_OBJECT * ob) DEPRECATED 10452 """) 10453 keep_elem_refs(pObject) 10454 retval = _fl_get_choice_text(pObject) 10455 return retval
10456 10457
10458 -def fl_set_choice_fontsize(pObject, size):
10459 """ 10460 fl_set_choice_fontsize(pObject, size) 10461 10462 Sets the font size inside the choice. 10463 10464 @param pObject : pointer to choice object 10465 @param size : font size of choice to be set 10466 """ 10467 10468 _fl_set_choice_fontsize = cfuncproto( 10469 load_so_libforms(), "fl_set_choice_fontsize", 10470 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10471 """void fl_set_choice_fontsize(FL_OBJECT * ob, int size) 10472 """) 10473 isize = convert_to_int(size) 10474 keep_elem_refs(pObject, size, isize) 10475 _fl_set_choice_fontsize(pObject, isize)
10476 10477
10478 -def fl_set_choice_fontstyle(pObject, style):
10479 """ 10480 fl_set_choice_fontstyle(pObject, style) 10481 10482 Sets the font style inside the choice. 10483 10484 @param pObject : pointer to choice object 10485 @param style : font style of choice to be set 10486 """ 10487 10488 _fl_set_choice_fontstyle = cfuncproto( 10489 load_so_libforms(), "fl_set_choice_fontstyle", 10490 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10491 """void fl_set_choice_fontstyle(FL_OBJECT * ob, int style) 10492 """) 10493 istyle = convert_to_int(style) 10494 keep_elem_refs(pObject, style, istyle) 10495 _fl_set_choice_fontstyle(pObject, istyle)
10496 10497
10498 -def fl_set_choice_align(pObject, align):
10499 """ 10500 fl_set_choice_align(pObject, align) 10501 10502 Sets alignment of text inside the choice. 10503 10504 @param pObject : pointer to choice object 10505 @param align : alignment of choice text to be set 10506 """ 10507 10508 _fl_set_choice_align = cfuncproto( 10509 load_so_libforms(), "fl_set_choice_align", 10510 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10511 """void fl_set_choice_align(FL_OBJECT * ob, int align) 10512 """) 10513 ialign = convert_to_int(align) 10514 keep_elem_refs(pObject, align, ialign) 10515 _fl_set_choice_align(pObject, ialign)
10516 10517
10518 -def fl_get_choice_item_mode(pObject, item):
10519 """ fl_get_choice_item_mode(pObject, item) -> mode num. 10520 """ 10521 10522 _fl_get_choice_item_mode = cfuncproto( 10523 load_so_libforms(), "fl_get_choice_item_mode", 10524 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 10525 """int fl_get_choice_item_mode(FL_OBJECT * ob, int item) DEPRECATED 10526 """) 10527 iitem = convert_to_int(item) 10528 keep_elem_refs(pObject, item, iitem) 10529 retval = _fl_get_choice_item_mode(pObject, iitem) 10530 return retval
10531 10532
10533 -def fl_set_choice_item_mode(pObject, itemnum, mode):
10534 """ 10535 fl_set_choice_item_mode(pObject, itemnum, mode) 10536 10537 Sets the mode of an item in a choice object. 10538 10539 @param pObject : pointer to choice object 10540 @param itemnum : item number whose mode is to be set 10541 @param mode : mode of item 10542 """ 10543 10544 _fl_set_choice_item_mode = cfuncproto( 10545 load_so_libforms(), "fl_set_choice_item_mode", 10546 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_uint], 10547 """void fl_set_choice_item_mode(FL_OBJECT * ob, int item, 10548 unsigned int mode) 10549 """) 10550 iitemnum = convert_to_int(itemnum) 10551 uimode = convert_to_uint(mode) 10552 keep_elem_refs(pObject, itemnum, mode, iitemnum, uimode) 10553 _fl_set_choice_item_mode(pObject, iitemnum, uimode)
10554 10555
10556 -def fl_set_choice_item_shortcut(pObject, item, sctext):
10557 """ fl_set_choice_item_shortcut(pObject, item, sstext) 10558 """ 10559 10560 _fl_set_choice_item_shortcut = cfuncproto( 10561 load_so_libforms(), "fl_set_choice_item_shortcut", 10562 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 10563 """void fl_set_choice_item_shortcut(FL_OBJECT * ob, int item, 10564 const char * sc) 10565 """) 10566 iitem = convert_to_int(item) 10567 ssctext = convert_to_string(sctext) 10568 keep_elem_refs(pObject, item, sctext, iitem, ssctext) 10569 _fl_set_choice_item_shortcut(pObject, iitem, ssctext)
10570 10571
10572 -def fl_set_choice_entries(pObject, pPopupEntry):
10573 """ fl_set_choice_entries(pObject, pPopupEntry) -> num. 10574 """ 10575 10576 _fl_set_choice_entries = cfuncproto( 10577 load_so_libforms(), "fl_set_choice_entries", 10578 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_PUP_ENTRY)], 10579 """int fl_set_choice_entries(FL_OBJECT * ob, FL_PUP_ENTRY * ent) DEPRECATED 10580 """) 10581 keep_elem_refs(pObject, pPopupEntry) 10582 retval = _fl_set_choice_entries(pObject, pPopupEntry) 10583 return retval
10584 10585
10586 -def fl_set_choice_notitle(pObject, n):
10587 """ fl_set_choice_notitle(pObject, n) -> num. 10588 """ 10589 10590 _fl_set_choice_notitle = cfuncproto( 10591 load_so_libforms(), "fl_set_choice_notitle", 10592 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 10593 """int fl_set_choice_notitle(FL_OBJECT * ob, int n) 10594 """) 10595 inum = convert_to_int(n) 10596 keep_elem_refs(pObject, n, inum) 10597 retval = _fl_set_choice_notitle(pObject, inum) 10598 return retval
10599 10600 10601 10602 ################################# 10603 # forms.h (clipbd.h) 10604 # prototypes for clipboard stuff 10605 ################################# 10606 10607 FL_LOSE_SELECTION_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), 10608 cty.c_long) 10609 FL_LOSE_SELECTION_CALLBACK = FL_LOSE_SELECTION_CB 10610
10611 -def fl_stuff_clipboard(pObject, clipbdtype, data, size, py_LoseSelectionCb):
10612 """ fl_stuff_clipboard(pObject, clipbdtype, data, size, py_LoseSelectionCb) -> num. 10613 """ 10614 10615 _fl_stuff_clipboard = cfuncproto( 10616 load_so_libforms(), "fl_stuff_clipboard", 10617 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_long, cty.c_void_p, 10618 cty.c_long, FL_LOSE_SELECTION_CB], 10619 """int fl_stuff_clipboard(FL_OBJECT * ob, long int type, 10620 const char * data, long int size, 10621 FL_LOSE_SELECTION_CB lose_callback) 10622 """) 10623 lclipbdtype = convert_to_long(clipbdtype) # type is not used 10624 lsize = convert_to_long(size) 10625 c_LoseSelectionCb = FL_LOSE_SELECTION_CB(py_LoseSelectionCb) 10626 keep_cfunc_refs(c_LoseSelectionCb, py_LoseSelectionCb) 10627 keep_elem_refs(pObject, clipbdtype, data, size, lclipbdtype, lsize) 10628 retval = _fl_stuff_clipboard(pObject, lclipbdtype, data, lsize, 10629 c_LoseSelectionCb) 10630 return retval
10631 10632 10633 FL_SELECTION_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), 10634 cty.c_long, cty.c_void_p, cty.c_long) 10635 FL_SELECTION_CALLBACK = FL_SELECTION_CB 10636
10637 -def fl_request_clipboard(pObject, clipbdtype, py_SelectionCb):
10638 """ fl_request_clipboard(pObject, clipbdtype, py_SelectionCb) -> num. 10639 """ 10640 10641 _fl_request_clipboard = cfuncproto( 10642 load_so_libforms(), "fl_request_clipboard", 10643 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_long, FL_SELECTION_CB], 10644 """int fl_request_clipboard(FL_OBJECT * ob, long int type, 10645 FL_SELECTION_CB got_it_callback) 10646 """) 10647 lclipbdtype = convert_to_long(clipbdtype) # type is not used 10648 c_SelectionCb = FL_SELECTION_CB(py_SelectionCb) 10649 keep_cfunc_refs(c_SelectionCb, py_SelectionCb) 10650 keep_elem_refs(pObject, clipbdtype, lclipbdtype) 10651 retval = _fl_request_clipboard(pObject, lclipbdtype, c_SelectionCb) 10652 return retval
10653 10654 10655 10656 ################################# 10657 # forms.h (clock.h) 10658 ################################# 10659 10660
10661 -def fl_create_clock(clocktype, x, y, w, h, label):
10662 """ 10663 fl_create_clock(clocktype, x, y, w, h, label) -> pObject 10664 10665 Creates a clock object. 10666 10667 @param clocktype : type of clock object to be created 10668 @param x : horizontal position of clock (upper-left corner) 10669 @param x : vertical position of clock (upper-left corner) 10670 @param w : width of clock in pixels 10671 @param h : height of clock in pixels 10672 @param label : text label of clock 10673 """ 10674 10675 _fl_create_clock = cfuncproto( 10676 load_so_libforms(), "fl_create_clock", 10677 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10678 FL_Coord, STRING], 10679 """FL_OBJECT * fl_create_clock(int type, FL_Coord x, FL_Coord y, 10680 FL_Coord w, FL_Coord h, const char * s) 10681 """) 10682 check_admitted_listvalues(clocktype, CLOCKTYPE_list) 10683 iclocktype = convert_to_int(clocktype) 10684 ix = convert_to_FL_Coord(x) 10685 iy = convert_to_FL_Coord(y) 10686 iw = convert_to_FL_Coord(w) 10687 ih = convert_to_FL_Coord(h) 10688 slabel = convert_to_string(label) 10689 keep_elem_refs(clocktype, x, y, w, h, label, iclocktype, ix, iy, 10690 iw, ih, slabel) 10691 retval = _fl_create_clock(iclocktype, ix, iy, iw, ih, slabel) 10692 return retval
10693 10694
10695 -def fl_add_clock(clocktype, x, y, w, h, label):
10696 """ 10697 fl_add_clock(clocktype, x, y, w, h, label) -> pObject 10698 10699 Adds a clock object. 10700 10701 @param clocktype : type of clock object to be added 10702 @param x : horizontal position of clock (upper-left corner) 10703 @param x : vertical position of clock (upper-left corner) 10704 @param w : width of clock in pixels 10705 @param h : height of clock in pixels 10706 @param label : text label of clock 10707 """ 10708 10709 _fl_add_clock = cfuncproto( 10710 load_so_libforms(), "fl_add_clock", 10711 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10712 FL_Coord, STRING], 10713 """FL_OBJECT * fl_add_clock(int type, FL_Coord x, FL_Coord y, 10714 FL_Coord w, FL_Coord h, const char * s) 10715 """) 10716 check_admitted_listvalues(clocktype, CLOCKTYPE_list) 10717 iclocktype = convert_to_int(clocktype) 10718 ix = convert_to_FL_Coord(x) 10719 iy = convert_to_FL_Coord(y) 10720 iw = convert_to_FL_Coord(w) 10721 ih = convert_to_FL_Coord(h) 10722 slabel = convert_to_string(label) 10723 keep_elem_refs(clocktype, x, y, w, h, label, iclocktype, ix, iy, 10724 iw, ih, slabel) 10725 retval = _fl_add_clock(iclocktype, ix, iy, iw, ih, slabel) 10726 return retval
10727 10728 10729 #def fl_get_clock(pObject, hr, mn, sec) *API change*
10730 -def fl_get_clock(pObject):
10731 """ fl_get_clock(pObject) -> hr, mn, sec 10732 10733 Returns time values from a clock object. 10734 10735 @param pObject : pointer to clock object 10736 """ 10737 10738 _fl_get_clock = cfuncproto( 10739 load_so_libforms(), "fl_get_clock", 10740 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 10741 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 10742 """void fl_get_clock(FL_OBJECT * ob, int * h, int * m, int * s) 10743 """) 10744 hr, phr = make_int_and_pointer() 10745 mn, pmn = make_int_and_pointer() 10746 sec, psec = make_int_and_pointer() 10747 keep_elem_refs(pObject, hr, mn, sec, phr, pmn, psec) 10748 _fl_get_clock(pObject, phr, pmn, psec) 10749 return hr, mn, sec
10750 10751
10752 -def fl_set_clock_adjustment(pObject, offset):
10753 """ fl_set_clock_adjustment(pObject, offset) -> num. 10754 """ 10755 10756 _fl_set_clock_adjustment = cfuncproto( 10757 load_so_libforms(), "fl_set_clock_adjustment", 10758 cty.c_long, [cty.POINTER(FL_OBJECT), cty.c_long], 10759 """long int fl_set_clock_adjustment(FL_OBJECT * ob, 10760 long int offset) 10761 """) 10762 loffset = convert_to_long(offset) 10763 keep_elem_refs(pObject, offset, loffset) 10764 retval = _fl_set_clock_adjustment(pObject, loffset) 10765 return retval
10766 10767
10768 -def fl_set_clock_ampm(pObject, y):
10769 """ fl_set_clock_ampm(pObject, y) 10770 """ 10771 10772 _fl_set_clock_ampm = cfuncproto( 10773 load_so_libforms(), "fl_set_clock_ampm", 10774 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10775 """void fl_set_clock_ampm(FL_OBJECT * ob, int y) 10776 """) 10777 iy = convert_to_int(y) 10778 keep_elem_refs(pObject, y, iy) 10779 _fl_set_clock_ampm(pObject, iy)
10780 10781 10782 10783 ###################### 10784 # forms.h (counter.h) 10785 ###################### 10786 10787 # Routines 10788
10789 -def fl_create_counter(countertype, x, y, w, h, label):
10790 """ 10791 fl_create_counter(countertype, x, y, w, h, label) -> pObject 10792 10793 Creates a counter object. 10794 10795 @param countertype : type of counter object to be created 10796 @param x : horizontal position of counter (upper-left corner) 10797 @param x : vertical position of counter (upper-left corner) 10798 @param w : width of counter in pixels 10799 @param h : height of counter in pixels 10800 @param label : text label of counter 10801 """ 10802 10803 _fl_create_counter = cfuncproto( 10804 load_so_libforms(), "fl_create_counter", 10805 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10806 FL_Coord, STRING], 10807 """FL_OBJECT * fl_create_counter(int type, FL_Coord x, FL_Coord y, 10808 FL_Coord w, FL_Coord h, const char * label) 10809 """) 10810 check_admitted_listvalues(countertype, COUNTERTYPE_list) 10811 icountertype = convert_to_int(countertype) 10812 ix = convert_to_FL_Coord(x) 10813 iy = convert_to_FL_Coord(y) 10814 iw = convert_to_FL_Coord(w) 10815 ih = convert_to_FL_Coord(h) 10816 slabel = convert_to_string(label) 10817 keep_elem_refs(countertype, x, y, w, h, label, icountertype, ix, iy, 10818 iw, ih, slabel) 10819 retval = _fl_create_counter(icountertype, ix, iy, iw, ih, slabel) 10820 return retval
10821 10822
10823 -def fl_add_counter(countertype, x, y, w, h, label):
10824 """ 10825 fl_add_counter(countertype, x, y, w, h, label) -> pObject 10826 10827 Adds a counter object. 10828 10829 @param countertype : type of counter object to be added 10830 @param x : horizontal position of counter (upper-left corner) 10831 @param x : vertical position of counter (upper-left corner) 10832 @param w : width of counter in pixels 10833 @param h : height of counter in pixels 10834 @param label : text label of counter 10835 """ 10836 10837 _fl_add_counter = cfuncproto( 10838 load_so_libforms(), "fl_add_counter", 10839 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10840 FL_Coord, STRING], 10841 """FL_OBJECT * fl_add_counter(int type, FL_Coord x, FL_Coord y, 10842 FL_Coord w, FL_Coord h, const char * label) 10843 """) 10844 check_admitted_listvalues(countertype, COUNTERTYPE_list) 10845 icountertype = convert_to_int(countertype) 10846 ix = convert_to_FL_Coord(x) 10847 iy = convert_to_FL_Coord(y) 10848 iw = convert_to_FL_Coord(w) 10849 ih = convert_to_FL_Coord(h) 10850 slabel = convert_to_string(label) 10851 keep_elem_refs(countertype, x, y, w, h, label, icountertype, ix, iy, 10852 iw, ih, slabel) 10853 retval = _fl_add_counter(icountertype, ix, iy, iw, ih, slabel) 10854 return retval
10855 10856
10857 -def fl_set_counter_value(pObject, val):
10858 """ fl_set_counter_value(pObject, val) 10859 """ 10860 10861 _fl_set_counter_value = cfuncproto( 10862 load_so_libforms(), "fl_set_counter_value", 10863 None, [cty.POINTER(FL_OBJECT), cty.c_double], 10864 """void fl_set_counter_value(FL_OBJECT * ob, double val) 10865 """) 10866 fval = convert_to_double(val) 10867 keep_elem_refs(pObject, val, fval) 10868 _fl_set_counter_value(pObject, fval)
10869 10870
10871 -def fl_set_counter_bounds(pObject, minbound, maxbound):
10872 """ fl_set_counter_bounds(pObject, minbound, maxbound) 10873 """ 10874 10875 _fl_set_counter_bounds = cfuncproto( 10876 load_so_libforms(), "fl_set_counter_bounds", 10877 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 10878 """void fl_set_counter_bounds(FL_OBJECT * ob, double min, 10879 double max) 10880 """) 10881 fminbound = convert_to_double(minbound) 10882 fmaxbound = convert_to_double(maxbound) 10883 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 10884 _fl_set_counter_bounds(pObject, fminbound, fmaxbound)
10885 10886
10887 -def fl_set_counter_step(pObject, s, l):
10888 """ fl_set_counter_step(pObject, s, l) 10889 """ 10890 10891 _fl_set_counter_step = cfuncproto( 10892 load_so_libforms(), "fl_set_counter_step", 10893 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 10894 """void fl_set_counter_step(FL_OBJECT * ob, double s, double l) 10895 """) 10896 fs = convert_to_double(s) 10897 fl = convert_to_double(l) 10898 keep_elem_refs(pObject, s, l, fs, fl) 10899 _fl_set_counter_step(pObject, fs, fl)
10900 10901
10902 -def fl_set_counter_precision(pObject, prec):
10903 """ fl_set_counter_precision(pObject, prec) 10904 """ 10905 10906 _fl_set_counter_precision = cfuncproto( 10907 load_so_libforms(), "fl_set_counter_precision", 10908 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10909 """void fl_set_counter_precision(FL_OBJECT * ob, int prec) 10910 """) 10911 iprec = convert_to_int(prec) 10912 keep_elem_refs(pObject, prec, iprec) 10913 _fl_set_counter_precision(pObject, iprec)
10914 10915
10916 -def fl_get_counter_precision(pObject):
10917 """ fl_get_counter_precision(pObject) -> num. 10918 """ 10919 10920 _fl_get_counter_precision = cfuncproto( 10921 load_so_libforms(), "fl_get_counter_precision", 10922 cty.c_int, [cty.POINTER(FL_OBJECT)], 10923 """int fl_get_counter_precision(FL_OBJECT * ob) 10924 """) 10925 keep_elem_refs(pObject) 10926 retval = _fl_get_counter_precision(pObject) 10927 return retval
10928 10929
10930 -def fl_set_counter_return(pObject, how):
10931 """ fl_set_counter_return(pObject, how) 10932 """ 10933 10934 _fl_set_counter_return = cfuncproto( 10935 load_so_libforms(), "fl_set_counter_return", 10936 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10937 """void fl_set_counter_return(FL_OBJECT * ob, int how) 10938 """) 10939 ihow = convert_to_int(how) 10940 keep_elem_refs(pObject, how, ihow) 10941 _fl_set_counter_return(pObject, ihow)
10942 10943
10944 -def fl_get_counter_value(pObject):
10945 """ fl_get_counter_value(pObject) -> num. 10946 """ 10947 10948 _fl_get_counter_value = cfuncproto( 10949 load_so_libforms(), "fl_get_counter_value", 10950 cty.c_double, [cty.POINTER(FL_OBJECT)], 10951 """double fl_get_counter_value(FL_OBJECT * ob) 10952 """) 10953 keep_elem_refs(pObject) 10954 retval = _fl_get_counter_value(pObject) 10955 return retval
10956 10957 10958 #def fl_get_counter_bounds(pObject, minbound, maxbound) *API change*
10959 -def fl_get_counter_bounds(pObject):
10960 """ fl_get_counter_bounds(pObject) -> minbound, maxbound 10961 """ 10962 10963 _fl_get_counter_bounds = cfuncproto( 10964 load_so_libforms(), "fl_get_counter_bounds", 10965 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 10966 cty.POINTER(cty.c_double)], 10967 """void fl_get_counter_bounds(FL_OBJECT * ob, double * min, 10968 double * max) 10969 """) 10970 minbound, pminbound = make_double_and_pointer() 10971 maxbound, pmaxbound = make_double_and_pointer() 10972 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 10973 _fl_get_counter_bounds(pObject, pminbound, pmaxbound) 10974 return minbound, maxbound
10975 10976 10977 #def fl_get_counter_step(pObject, s, l) *API change*
10978 -def fl_get_counter_step(pObject):
10979 """ fl_get_counter_step(pObject) -> s, l 10980 """ 10981 10982 _fl_get_counter_step = cfuncproto( 10983 load_so_libforms(), "fl_get_counter_step", 10984 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 10985 cty.POINTER(cty.c_double)], 10986 """void fl_get_counter_step(FL_OBJECT * ob, double * s, 10987 double * l) 10988 """) 10989 s, ps = make_double_and_pointer() 10990 l, pl = make_double_and_pointer() 10991 keep_elem_refs(pObject, s, l, ps, pl) 10992 _fl_get_counter_step(pObject, ps, pl) 10993 return s, l
10994 10995 10996 FL_VAL_FILTER = cty.CFUNCTYPE(STRING, cty.POINTER(FL_OBJECT), cty.c_double, \ 10997 cty.c_int) 10998
10999 -def fl_set_counter_filter(pObject, py_ValFilter):
11000 """ fl_set_counter_filter(pObject, ValFilter) 11001 """ 11002 11003 _fl_set_counter_filter = cfuncproto( 11004 load_so_libforms(), "fl_set_counter_filter", 11005 None, [cty.POINTER(FL_OBJECT), FL_VAL_FILTER], 11006 """void fl_set_counter_filter(FL_OBJECT * ob, 11007 FL_VAL_FILTER filter) 11008 """) 11009 c_ValFilter = FL_VAL_FILTER(py_ValFilter) 11010 keep_cfunc_refs(c_ValFilter, py_ValFilter) 11011 keep_elem_refs(pObject) 11012 _fl_set_counter_filter(pObject, c_ValFilter)
11013 11014 11015 # Functions to set and get the timeout value used by the 11016 # counter code to control modification of the counter value. 11017
11018 -def fl_get_counter_repeat(pObject):
11019 """ fl_get_counter_repeat(pObject) -> num. 11020 """ 11021 11022 _fl_get_counter_repeat = cfuncproto( 11023 load_so_libforms(), "fl_get_counter_repeat", 11024 cty.c_int, [cty.POINTER(FL_OBJECT)], 11025 """int fl_get_counter_repeat(FL_OBJECT * ob) 11026 """) 11027 keep_elem_refs(pObject) 11028 retval = _fl_get_counter_repeat(pObject) 11029 return retval
11030 11031
11032 -def fl_set_counter_repeat(pObject, msec):
11033 """ fl_set_counter_repeat(pObject, msec) 11034 """ 11035 11036 _fl_set_counter_repeat = cfuncproto( 11037 load_so_libforms(), "fl_set_counter_repeat", 11038 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11039 """void fl_set_counter_repeat(FL_OBJECT * ob, int millisec) 11040 """) 11041 imsec = convert_to_int(msec) 11042 keep_elem_refs(pObject, msec, imsec) 11043 _fl_set_counter_repeat(pObject, imsec)
11044 11045
11046 -def fl_get_counter_min_repeat(pObject):
11047 """ fl_get_counter_min_repeat(pObject) -> num. 11048 """ 11049 11050 _fl_get_counter_min_repeat = cfuncproto( 11051 load_so_libforms(), "fl_get_counter_min_repeat", 11052 cty.c_int, [cty.POINTER(FL_OBJECT)], 11053 """int fl_get_counter_min_repeat(FL_OBJECT * ob) 11054 """) 11055 keep_elem_refs(pObject) 11056 retval = _fl_get_counter_min_repeat(pObject) 11057 return retval
11058 11059
11060 -def fl_set_counter_min_repeat(pObject, msec):
11061 """ fl_set_counter_min_repeat(pObject, msec) 11062 """ 11063 11064 _fl_set_counter_min_repeat = cfuncproto( 11065 load_so_libforms(), "fl_set_counter_min_repeat", 11066 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11067 """void fl_set_counter_min_repeat(FL_OBJECT * ob, int millisec) 11068 """) 11069 imsec = convert_to_int(msec) 11070 keep_elem_refs(pObject, msec, imsec) 11071 _fl_set_counter_min_repeat(pObject, imsec)
11072 11073
11074 -def fl_get_counter_speedjump(pObject):
11075 """ fl_get_counter_speedjump(pObject) -> num. 11076 """ 11077 11078 _fl_get_counter_speedjump = cfuncproto( 11079 load_so_libforms(), "fl_get_counter_speedjump", 11080 cty.c_int, [cty.POINTER(FL_OBJECT)], 11081 """int fl_get_counter_speedjump(FL_OBJECT * ob) 11082 """) 11083 keep_elem_refs(pObject) 11084 retval = _fl_get_counter_speedjump(pObject) 11085 return retval
11086 11087
11088 -def fl_set_counter_speedjump(pObject, yesno):
11089 """ fl_set_counter_speedjump(pObject, yesno) 11090 """ 11091 11092 _fl_set_counter_speedjump = cfuncproto( 11093 load_so_libforms(), "fl_set_counter_speedjump", 11094 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11095 """void fl_set_counter_speedjump(FL_OBJECT * ob, int yes_no) 11096 """) 11097 iyesno = convert_to_int(yesno) 11098 keep_elem_refs(pObject, yesno, iyesno) 11099 _fl_set_counter_speedjump(pObject, iyesno)
11100 11101 11102 11103 ############################# 11104 # forms.h (cursor.h) 11105 # Cursor defs and prototypes 11106 ############################# 11107
11108 -def fl_set_cursor(win, cursnum):
11109 """ 11110 fl_set_cursor(win, cursnum) 11111 11112 Set cursor for window to provided cursor number name. Name 11113 is either the standard XC_ or Form defined 11114 11115 @param win : window 11116 @param cursnum : cursor number 11117 """ 11118 11119 _fl_set_cursor = cfuncproto( 11120 load_so_libforms(), "fl_set_cursor", 11121 None, [Window, cty.c_int], 11122 """void fl_set_cursor(Window win, int name) 11123 """) 11124 ulwin = convert_to_Window(win) 11125 icursnum = convert_to_int(cursnum) 11126 keep_elem_refs(win, cursnum, ulwin, icursnum) 11127 _fl_set_cursor(ulwin, icursnum)
11128 11129
11130 -def fl_set_cursor_color(cursnum, fgcolr, bgcolr):
11131 """ 11132 fl_set_cursor_color(cursnum, fgcolr, bgcolr) 11133 11134 Sets foreground and background colors for cursor. 11135 11136 @param cursnum : cursor number 11137 @param fgcolr : foreground color to be set 11138 @param bgcolr : background color to be set 11139 """ 11140 11141 _fl_set_cursor_color = cfuncproto( 11142 load_so_libforms(), "fl_set_cursor_color", 11143 None, [cty.c_int, FL_COLOR, FL_COLOR], 11144 """void fl_set_cursor_color(int name, FL_COLOR fg, FL_COLOR bg) 11145 """) 11146 icursnum = convert_to_int(cursnum) 11147 ulfgcolr = convert_to_FL_COLOR(fgcolr) 11148 ulbgcolr = convert_to_FL_COLOR(bgcolr) 11149 keep_elem_refs(cursnum, fgcolr, bgcolr, icursnum, ulfgcolr, ulbgcolr) 11150 _fl_set_cursor_color(icursnum, ulfgcolr, ulbgcolr)
11151 11152
11153 -def fl_create_bitmap_cursor(source, maskstr, w, h, hotx, hoty):
11154 """ fl_create_bitmap_cursor(source, maskstr, w, h, hotx, hoty) -> num. 11155 """ 11156 11157 _fl_create_bitmap_cursor = cfuncproto( 11158 load_so_libforms(), "fl_create_bitmap_cursor", 11159 cty.c_int, [STRING, STRING, cty.c_int, cty.c_int, cty.c_int, 11160 cty.c_int], 11161 """int fl_create_bitmap_cursor(const char * source, 11162 const char * mask, int w, int h, int hotx, int hoty) 11163 """) 11164 ssource = convert_to_string(source) 11165 smaskstr = convert_to_string(maskstr) 11166 iw = convert_to_int(w) 11167 ih = convert_to_FL_Coord(h) 11168 ihotx = convert_to_int(hotx) 11169 ihoty = convert_to_int(hoty) 11170 keep_elem_refs(source, maskstr, w, h, hotx, hoty, ssource, smaskstr, 11171 iw, ih, ihotx, ihoty) 11172 retval = _fl_create_bitmap_cursor(ssource, smaskstr, iw, ih, ihotx, ihoty) 11173 return retval
11174 11175
11176 -def fl_create_animated_cursor(curnums, timeout):
11177 """ fl_create_animated_cursor(curnums, timeout) -> num. 11178 """ 11179 11180 _fl_create_animated_cursor = cfuncproto( 11181 load_so_libforms(), "fl_create_animated_cursor", 11182 cty.c_int, [cty.POINTER(cty.c_int), cty.c_int], 11183 """int fl_create_animated_cursor(int * cur_names, int timeout) 11184 """) 11185 pcurnums = cty.cast(curnums, cty.POINTER(cty.c_int)) 11186 #print "pcurnums", pcurnums 11187 itimeout = convert_to_int(timeout) 11188 keep_elem_refs(curnums, timeout, pcurnums, itimeout) 11189 retval = _fl_create_animated_cursor(pcurnums, itimeout) 11190 return retval
11191 11192
11193 -def fl_get_cursor_byname(cursnum):
11194 """ 11195 fl_get_cursor_byname(cursnum) -> cursor 11196 11197 Return cursor corresponding to number. 11198 11199 @param cursnum : cursor number 11200 """ 11201 11202 _fl_get_cursor_byname = cfuncproto( 11203 load_so_libforms(), "fl_get_cursor_byname", 11204 Cursor, [cty.c_int], 11205 """Cursor fl_get_cursor_byname(int name) 11206 """) 11207 icursnum = convert_to_int(cursnum) 11208 keep_elem_refs(cursnum, icursnum) 11209 retval = _fl_get_cursor_byname(icursnum) 11210 return retval
11211 11212
11213 -def fl_reset_cursor(win):
11214 """ 11215 Reset used cursor, reverting to default one. 11216 """ 11217 11218 fl_set_cursor(win, FL_DEFAULT_CURSOR)
11219 11220 11221 11222 ################### 11223 # forms.h (dial.h) 11224 ################### 11225 11226 # Routines 11227
11228 -def fl_create_dial(dialtype, x, y, w, h, label):
11229 """ fl_create_dial(dialtype, x, y, w, h, label) -> pObject 11230 """ 11231 11232 _fl_create_dial = cfuncproto( 11233 load_so_libforms(), "fl_create_dial", 11234 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 11235 FL_Coord, STRING], 11236 """FL_OBJECT * fl_create_dial(int type, FL_Coord x, FL_Coord y, 11237 FL_Coord w, FL_Coord h, const char * label) 11238 """) 11239 check_admitted_listvalues(dialtype, DIALTYPE_list) 11240 idialtype = convert_to_int(dialtype) 11241 ix = convert_to_FL_Coord(x) 11242 iy = convert_to_FL_Coord(y) 11243 iw = convert_to_FL_Coord(w) 11244 ih = convert_to_FL_Coord(h) 11245 slabel = convert_to_string(label) 11246 keep_elem_refs(dialtype, x, y, w, h, label, idialtype, ix, iy, 11247 iw, ih, slabel) 11248 retval = _fl_create_dial(idialtype, ix, iy, iw, ih, slabel) 11249 return retval
11250 11251
11252 -def fl_add_dial(dialtype, x, y, w, h, label):
11253 """ fl_add_dial(dialtype, x, y, w, h, label) -> pObject 11254 """ 11255 11256 _fl_add_dial = cfuncproto( 11257 load_so_libforms(), "fl_add_dial", 11258 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 11259 FL_Coord, STRING], 11260 """FL_OBJECT * fl_add_dial(int type, FL_Coord x, FL_Coord y, 11261 FL_Coord w, FL_Coord h, const char * label) 11262 """) 11263 check_admitted_listvalues(dialtype, DIALTYPE_list) 11264 idialtype = convert_to_int(dialtype) 11265 ix = convert_to_FL_Coord(x) 11266 iy = convert_to_FL_Coord(y) 11267 iw = convert_to_FL_Coord(w) 11268 ih = convert_to_FL_Coord(h) 11269 slabel = convert_to_string(label) 11270 keep_elem_refs(dialtype, x, y, w, h, label, idialtype, ix, iy, 11271 iw, ih, slabel) 11272 retval = _fl_add_dial(idialtype, ix, iy, iw, ih, slabel) 11273 return retval
11274 11275
11276 -def fl_set_dial_value(pObject, val):
11277 """ fl_set_dial_value(pObject, val) 11278 """ 11279 11280 _fl_set_dial_value = cfuncproto( 11281 load_so_libforms(), "fl_set_dial_value", 11282 None, [cty.POINTER(FL_OBJECT), cty.c_double], 11283 """void fl_set_dial_value(FL_OBJECT * ob, double val) 11284 """) 11285 fval = convert_to_double(val) 11286 keep_elem_refs(pObject, val, fval) 11287 _fl_set_dial_value(pObject, fval)
11288 11289
11290 -def fl_get_dial_value(pObject):
11291 """ fl_get_dial_value(pObject) -> num. 11292 """ 11293 11294 _fl_get_dial_value = cfuncproto( 11295 load_so_libforms(), "fl_get_dial_value", 11296 cty.c_double, [cty.POINTER(FL_OBJECT)], 11297 """double fl_get_dial_value(FL_OBJECT * ob) 11298 """) 11299 keep_elem_refs(pObject) 11300 retval = _fl_get_dial_value(pObject) 11301 return retval
11302 11303
11304 -def fl_set_dial_bounds(pObject, minbound, maxbound):
11305 """ fl_set_dial_bounds(pObject, minbound, maxbound) 11306 """ 11307 11308 _fl_set_dial_bounds = cfuncproto( 11309 load_so_libforms(), "fl_set_dial_bounds", 11310 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 11311 """void fl_set_dial_bounds(FL_OBJECT * ob, double min, 11312 double max) 11313 """) 11314 fminbound = convert_to_double(minbound) 11315 fmaxbound = convert_to_double(maxbound) 11316 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 11317 _fl_set_dial_bounds(pObject, fminbound, fmaxbound)
11318 11319 11320 #def fl_get_dial_bounds(pObject, minbound, maxbound) *API change*
11321 -def fl_get_dial_bounds(pObject):
11322 """ fl_get_dial_bounds(pObject) -> minbound, maxbound 11323 """ 11324 11325 _fl_get_dial_bounds = cfuncproto( 11326 load_so_libforms(), "fl_get_dial_bounds", 11327 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 11328 cty.POINTER(cty.c_double)], 11329 """void fl_get_dial_bounds(FL_OBJECT * ob, double * min, 11330 double * max) 11331 """) 11332 minbound, pminbound = make_double_and_pointer() 11333 maxbound, pmaxbound = make_double_and_pointer() 11334 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 11335 _fl_get_dial_bounds(pObject, pminbound, pmaxbound) 11336 return minbound, maxbound
11337 11338
11339 -def fl_set_dial_step(pObject, value):
11340 """ fl_set_dial_step(pObject, value) 11341 """ 11342 11343 _fl_set_dial_step = cfuncproto( 11344 load_so_libforms(), "fl_set_dial_step", 11345 None, [cty.POINTER(FL_OBJECT), cty.c_double], 11346 """void fl_set_dial_step(FL_OBJECT * ob, double value) 11347 """) 11348 fvalue = convert_to_double(value) 11349 keep_elem_refs(pObject, value, fvalue) 11350 _fl_set_dial_step(pObject, fvalue)
11351 11352
11353 -def fl_set_dial_return(pObject, value):
11354 """ fl_set_dial_return(pObject, value) 11355 """ 11356 11357 _fl_set_dial_return = cfuncproto( 11358 load_so_libforms(), "fl_set_dial_return", 11359 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11360 """void fl_set_dial_return(FL_OBJECT * ob, int value) 11361 """) 11362 ivalue = convert_to_int(value) 11363 keep_elem_refs(pObject, value, ivalue) 11364 _fl_set_dial_return(pObject, ivalue)
11365 11366
11367 -def fl_set_dial_angles(pObject, angmin, angmax):
11368 """ fl_set_dial_angles(pObject, angmin, angmax) 11369 """ 11370 11371 _fl_set_dial_angles = cfuncproto( 11372 load_so_libforms(), "fl_set_dial_angles", 11373 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 11374 """void fl_set_dial_angles(FL_OBJECT * ob, double amin, 11375 double amax) 11376 """) 11377 fangmin = convert_to_double(angmin) 11378 fangmax = convert_to_double(angmax) 11379 keep_elem_refs(pObject, angmin, angmax, fangmin, fangmax) 11380 _fl_set_dial_angles(pObject, fangmin, fangmax)
11381 11382
11383 -def fl_set_dial_cross(pObject, flag):
11384 """ fl_set_dial_cross(pObject, flag) 11385 """ 11386 11387 _fl_set_dial_cross = cfuncproto( 11388 load_so_libforms(), "fl_set_dial_cross", 11389 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11390 """void fl_set_dial_cross(FL_OBJECT * ob, int flag) 11391 """) 11392 iflag = convert_to_int(flag) 11393 keep_elem_refs(pObject, flag, iflag) 11394 _fl_set_dial_cross(pObject, iflag)
11395 11396 11397 fl_set_dial_crossover = fl_set_dial_cross 11398 11399
11400 -def fl_set_dial_direction(pObject, directn):
11401 """ fl_set_dial_direction(pObject, directn) 11402 """ 11403 11404 _fl_set_dial_direction = cfuncproto( 11405 load_so_libforms(), "fl_set_dial_direction", 11406 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11407 """void fl_set_dial_direction(FL_OBJECT * ob, int dir) 11408 """) 11409 idirectn = convert_to_int(directn) 11410 keep_elem_refs(pObject, directn, idirectn) 11411 _fl_set_dial_direction(pObject, idirectn)
11412 11413 11414 11415 ############################################ 11416 # forms.h (filesys.h) 11417 # Convenience functions to read a directory 11418 ############################################ 11419 11420 # read dir with pattern filtering. All dirs read might be cached. 11421 # must not change dirlist in anyway. 11422 11423 #def fl_get_dirlist(directory, pattern, n, rescan) *API change*
11424 -def fl_get_dirlist(directory, pattern, rescan):
11425 """ fl_get_dirlist(directory, pattern, rescan) -> pDirList, n 11426 """ 11427 11428 _fl_get_dirlist = cfuncproto( 11429 load_so_libforms(), "fl_get_dirlist", 11430 cty.POINTER(FL_Dirlist), [STRING, STRING, cty.POINTER(cty.c_int), 11431 cty.c_int], 11432 """const char * fl_get_dirlist(const char * dir, 11433 const char * pattern, int * n, int rescan) 11434 """) 11435 sdirectory = convert_to_string(directory) 11436 spattern = convert_to_string(pattern) 11437 n, pn = make_int_and_pointer() 11438 irescan = convert_to_int(rescan) 11439 keep_elem_refs(directory, pattern, n, rescan, sdirectory, spattern, 11440 pn, irescan) 11441 retval = _fl_get_dirlist(sdirectory, spattern, pn, irescan) 11442 return retval, n
11443 11444 11445 FL_DIRLIST_FILTER = cty.CFUNCTYPE(cty.c_int, STRING, cty.c_int) 11446
11447 -def fl_set_dirlist_filter(py_DirFilter):
11448 """ fl_set_dirlist_filter(py_DirFilter) -> dirlist_filter func. 11449 """ 11450 11451 _fl_set_dirlist_filter = cfuncproto( 11452 load_so_libforms(), "fl_set_dirlist_filter", 11453 FL_DIRLIST_FILTER, [FL_DIRLIST_FILTER], 11454 """FL_DIRLIST_FILTER fl_set_dirlist_filter( \ 11455 FL_DIRLIST_FILTER filter) 11456 """) 11457 c_DirFilter = FL_DIRLIST_FILTER(py_DirFilter) 11458 keep_cfunc_refs(c_DirFilter, py_DirFilter) 11459 retval = _fl_set_dirlist_filter(c_DirFilter) 11460 return retval
11461 11462
11463 -def fl_set_dirlist_sort(method):
11464 """ fl_set_dirlist_sort(method) -> num. 11465 """ 11466 11467 _fl_set_dirlist_sort = cfuncproto( 11468 load_so_libforms(), "fl_set_dirlist_sort", 11469 cty.c_int, [cty.c_int], 11470 """int fl_set_dirlist_sort(int method) 11471 """) 11472 imethod = convert_to_int(method) 11473 keep_elem_refs(method, imethod) 11474 retval = _fl_set_dirlist_sort(imethod) 11475 return retval
11476 11477
11478 -def fl_set_dirlist_filterdir(yes):
11479 """ fl_set_dirlist_filterdir(yes) -> num. 11480 """ 11481 11482 _fl_set_dirlist_filterdir = cfuncproto( 11483 load_so_libforms(), "fl_set_dirlist_filterdir", 11484 cty.c_int, [cty.c_int], 11485 """int fl_set_dirlist_filterdir(int yes) 11486 """) 11487 iyes = convert_to_int(yes) 11488 keep_elem_refs(yes, iyes) 11489 retval = _fl_set_dirlist_filterdir(iyes) 11490 return retval
11491 11492
11493 -def fl_free_dirlist(pDirList):
11494 """ fl_free_dirlist(pDirList) 11495 """ 11496 11497 _fl_free_dirlist = cfuncproto( 11498 load_so_libforms(), "fl_free_dirlist", 11499 None, [cty.POINTER(FL_Dirlist)], 11500 """void fl_free_dirlist(FL_Dirlist * dl) 11501 """) 11502 keep_elem_refs(pDirList) 11503 _fl_free_dirlist(pDirList)
11504 11505 11506 # Free all directory caches 11507
11508 -def fl_free_all_dirlist():
11509 """ fl_free_all_dirlist() 11510 """ 11511 11512 _fl_free_all_dirlist = cfuncproto( 11513 load_so_libforms(), "fl_free_all_dirlist", 11514 None, [], 11515 """void fl_free_all_dirlist() 11516 """) 11517 _fl_free_all_dirlist()
11518 11519
11520 -def fl_is_valid_dir(name):
11521 """ fl_is_valid_dir(name) -> num. 11522 """ 11523 11524 _fl_is_valid_dir = cfuncproto( 11525 load_so_libforms(), "fl_is_valid_dir", 11526 cty.c_int, [STRING], 11527 """int fl_is_valid_dir(const char * name) 11528 """) 11529 sname = convert_to_string(name) 11530 keep_elem_refs(name, sname) 11531 retval = _fl_is_valid_dir(sname) 11532 return retval
11533 11534
11535 -def fl_fmtime(timestr):
11536 """ fl_fmtime(timestr) -> num. 11537 """ 11538 11539 _fl_fmtime = cfuncproto( 11540 load_so_libforms(), "fl_fmtime", 11541 cty.c_ulong, [STRING], 11542 """long unsigned int fl_fmtime(const char * s) 11543 """) 11544 stimestr = convert_to_string(timestr) 11545 keep_elem_refs(timestr, stimestr) 11546 retval = _fl_fmtime(stimestr) 11547 return retval
11548 11549
11550 -def fl_fix_dirname(directory):
11551 """ fl_fix_dirname(directory) -> dirname string 11552 """ 11553 11554 _fl_fix_dirname = cfuncproto( 11555 load_so_libforms(), "fl_fix_dirname", 11556 STRING, [STRING], 11557 """char * fl_fix_dirname(char * dir) 11558 """) 11559 sdirectory = convert_to_string(directory) 11560 keep_elem_refs(directory, sdirectory) 11561 retval = _fl_fix_dirname(sdirectory) 11562 return retval
11563 11564 11565 11566 ################### 11567 # forms.h (flps.h) 11568 ################### 11569 11570 # postscript stuff 11571
11572 -def flps_init():
11573 """ flps_init() -> flps_control class 11574 """ 11575 11576 _flps_init = cfuncproto( 11577 load_so_libflimage(), "flps_init", 11578 cty.POINTER(FLPS_CONTROL), [], 11579 """)FLPS_CONTROL * flps_init() 11580 """) 11581 retval = _flps_init() 11582 return retval
11583 11584
11585 -def fl_object_ps_dump(pObject, fname):
11586 """ fl_object_ps_dump(pObject, fname) -> num. 11587 """ 11588 11589 _fl_object_ps_dump = cfuncproto( 11590 load_so_libflimage(), "fl_object_ps_dump", 11591 cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 11592 """int fl_object_ps_dump(FL_OBJECT * ob, const char * fname) 11593 """) 11594 sfname = convert_to_string(fname) 11595 keep_elem_refs(pObject, fname, sfname) 11596 retval = _fl_object_ps_dump(pObject, sfname) 11597 return retval
11598 11599 11600 11601 ########################## 11602 # forms.h (formbrowser.h) 11603 ########################## 11604
11605 -def fl_addto_formbrowser(pObject, pForm):
11606 """ fl_addto_formbrowser(pObject, pForm) -> num. 11607 """ 11608 11609 _fl_addto_formbrowser = cfuncproto( 11610 load_so_libforms(), "fl_addto_formbrowser", 11611 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 11612 """int fl_addto_formbrowser(FL_OBJECT * ob, FL_FORM * form) 11613 """) 11614 keep_elem_refs(pObject, pForm) 11615 retval = _fl_addto_formbrowser(pObject, pForm) 11616 return retval
11617 11618
11619 -def fl_delete_formbrowser_bynumber(pObject, num):
11620 """ fl_delete_formbrowser_bynumber(pObject, num) -> pForm 11621 """ 11622 11623 _fl_delete_formbrowser_bynumber = cfuncproto( 11624 load_so_libforms(), "fl_delete_formbrowser_bynumber", 11625 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 11626 """FL_FORM * fl_delete_formbrowser_bynumber(FL_OBJECT * ob, 11627 int num) 11628 """) 11629 inum = convert_to_int(num) 11630 keep_elem_refs(pObject, num, inum) 11631 retval = _fl_delete_formbrowser_bynumber(pObject, inum) 11632 return retval
11633 11634
11635 -def fl_delete_formbrowser(pObject, pFormCandidate):
11636 """ fl_delete_formbrowser(pObject, pFormCandidate) -> num. 11637 """ 11638 11639 _fl_delete_formbrowser = cfuncproto( 11640 load_so_libforms(), "fl_delete_formbrowser", 11641 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 11642 """int fl_delete_formbrowser(FL_OBJECT * ob, 11643 FL_FORM * candidate_form) 11644 """) 11645 keep_elem_refs(pObject, pFormCandidate) 11646 retval = _fl_delete_formbrowser(pObject, pFormCandidate) 11647 return retval
11648 11649
11650 -def fl_replace_formbrowser(pObject, num, pForm):
11651 """ fl_replace_formbrowser(pObject, num, pForm) 11652 """ 11653 11654 _fl_replace_formbrowser = cfuncproto( 11655 load_so_libforms(), "fl_replace_formbrowser", 11656 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int, 11657 cty.POINTER(FL_FORM)], 11658 """FL_FORM * fl_replace_formbrowser(FL_OBJECT * ob, int num, 11659 FL_FORM * form) 11660 """) 11661 inum = convert_to_int(num) 11662 keep_elem_refs(pObject, num, pForm, inum) 11663 retval = _fl_replace_formbrowser(pObject, inum, pForm) 11664 return retval
11665 11666
11667 -def fl_insert_formbrowser(pObject, line, pFormNew):
11668 """ fl_insert_formbrowser(pObject, line, pFormNew) -> num. 11669 """ 11670 11671 _fl_insert_formbrowser = cfuncproto( 11672 load_so_libforms(), "fl_insert_formbrowser", 11673 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, \ 11674 cty.POINTER(FL_FORM)], 11675 """int fl_insert_formbrowser(FL_OBJECT * ob, int line, 11676 FL_FORM * new_form) 11677 """) 11678 iline = convert_to_int(line) 11679 keep_elem_refs(pObject, line, iline, pFormNew) 11680 retval = _fl_insert_formbrowser(pObject, iline, pFormNew) 11681 return retval
11682 11683 11684 #def fl_get_formbrowser_area(pObject, x, y, w, h) *API change*
11685 -def fl_get_formbrowser_area(pObject):
11686 """ fl_get_formbrowser_area(pObject) -> num., x, y, w, h 11687 """ 11688 11689 _fl_get_formbrowser_area = cfuncproto( 11690 load_so_libforms(), "fl_get_formbrowser_area", 11691 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 11692 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), \ 11693 cty.POINTER(cty.c_int)], 11694 """int fl_get_formbrowser_area(FL_OBJECT * ob, int * x, int * y, 11695 int * w, int * h) 11696 """) 11697 x, px = make_int_and_pointer() 11698 y, py = make_int_and_pointer() 11699 w, pw = make_int_and_pointer() 11700 h, ph = make_int_and_pointer() 11701 keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 11702 retval = _fl_get_formbrowser_area(pObject, px, py, pw, ph) 11703 return retval, x, y, w, h
11704 11705
11706 -def fl_set_formbrowser_scroll(pObject, how):
11707 """ fl_set_formbrowser_scroll(pObject, how) 11708 """ 11709 11710 _fl_set_formbrowser_scroll = cfuncproto( 11711 load_so_libforms(), "fl_set_formbrowser_scroll", 11712 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11713 """void fl_set_formbrowser_scroll(FL_OBJECT * ob, int how) 11714 """) 11715 ihow = convert_to_int(how) 11716 keep_elem_refs(pObject, how, ihow) 11717 _fl_set_formbrowser_scroll(pObject, ihow)
11718 11719
11720 -def fl_set_formbrowser_hscrollbar(pObject, how):
11721 """ fl_set_formbrowser_hscrollbar(pObject, how) 11722 """ 11723 11724 _fl_set_formbrowser_hscrollbar = cfuncproto( 11725 load_so_libforms(), "fl_set_formbrowser_hscrollbar", 11726 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11727 """void fl_set_formbrowser_hscrollbar(FL_OBJECT * ob, int how) 11728 """) 11729 ihow = convert_to_int(how) 11730 keep_elem_refs(pObject, how, ihow) 11731 _fl_set_formbrowser_hscrollbar(pObject, ihow)
11732 11733
11734 -def fl_set_formbrowser_vscrollbar(pObject, how):
11735 """ fl_set_formbrowser_vscrollbar(pObject, how) 11736 """ 11737 11738 _fl_set_formbrowser_vscrollbar = cfuncproto( 11739 load_so_libforms(), "fl_set_formbrowser_vscrollbar", 11740 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11741 """void fl_set_formbrowser_vscrollbar(FL_OBJECT * ob, int how) 11742 """) 11743 ihow = convert_to_int(how) 11744 keep_elem_refs(pObject, how, ihow) 11745 _fl_set_formbrowser_vscrollbar(pObject, ihow)
11746 11747
11748 -def fl_get_formbrowser_topform(pObject):
11749 """ fl_get_formbrowser_topform(pObject) -> pForm 11750 """ 11751 11752 _fl_get_formbrowser_topform = cfuncproto( 11753 load_so_libforms(), "fl_get_formbrowser_topform", 11754 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 11755 """FL_FORM * fl_get_formbrowser_topform(FL_OBJECT * ob) 11756 """) 11757 keep_elem_refs(pObject) 11758 retval = _fl_get_formbrowser_topform(pObject) 11759 return retval
11760 11761
11762 -def fl_set_formbrowser_topform(pObject, pForm):
11763 """ fl_set_formbrowser_topform(pObject, pForm) -> num. 11764 """ 11765 11766 _fl_set_formbrowser_topform = cfuncproto( 11767 load_so_libforms(), "fl_set_formbrowser_topform", 11768 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 11769 """int fl_set_formbrowser_topform(FL_OBJECT * ob, FL_FORM * form) 11770 """) 11771 keep_elem_refs(pObject, pForm) 11772 retval = _fl_set_formbrowser_topform(pObject, pForm) 11773 return retval
11774 11775
11776 -def fl_set_formbrowser_topform_bynumber(pObject, n):
11777 """ fl_set_formbrowser_topform_bynumber(pObject, n) -> pForm 11778 """ 11779 11780 _fl_set_formbrowser_topform_bynumber = cfuncproto( 11781 load_so_libforms(), "fl_set_formbrowser_topform_bynumber", 11782 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 11783 """FL_FORM * fl_set_formbrowser_topform_bynumber( \ 11784 FL_OBJECT * ob, int n) 11785 """) 11786 inum = convert_to_int(n) 11787 keep_elem_refs(pObject, n, inum) 11788 retval = _fl_set_formbrowser_topform_bynumber(pObject, inum) 11789 return retval
11790 11791
11792 -def fl_set_formbrowser_xoffset(pObject, offset):
11793 """ 11794 fl_set_formbrowser_xoffset(pObject, offset) -> num. 11795 11796 Scrolls within a formbrowser in horizontal direction. 11797 11798 @param pObject : pointer to formbrowser object 11799 @param offset : positive number, measuring in pixels the offset 11800 from the the natural position from the left 11801 """ 11802 11803 _fl_set_formbrowser_xoffset = cfuncproto( 11804 load_so_libforms(), "fl_set_formbrowser_xoffset", 11805 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 11806 """int fl_set_formbrowser_xoffset(FL_OBJECT * ob, int offset) 11807 """) 11808 ioffset = convert_to_int(offset) 11809 keep_elem_refs(pObject, offset, ioffset) 11810 retval = _fl_set_formbrowser_xoffset(pObject, ioffset) 11811 return retval
11812 11813
11814 -def fl_set_formbrowser_yoffset(pObject, offset):
11815 """ 11816 fl_set_formbrowser_yoffset(pObject, offset) -> num. 11817 11818 Scrolls within a formbrowser in vertical direction. 11819 11820 @param pObject : pointer to formbrowser object 11821 @param offset : positive number, measuring in pixels the offset 11822 from the the natural position from the top 11823 """ 11824 11825 _fl_set_formbrowser_yoffset = cfuncproto( 11826 load_so_libforms(), "fl_set_formbrowser_yoffset", 11827 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 11828 """int fl_set_formbrowser_yoffset(FL_OBJECT * ob, int offset) 11829 """) 11830 ioffset = convert_to_int(offset) 11831 keep_elem_refs(pObject, offset, ioffset) 11832 retval = _fl_set_formbrowser_yoffset(pObject, ioffset) 11833 return retval
11834 11835
11836 -def fl_get_formbrowser_xoffset(pObject):
11837 """ 11838 fl_get_formbrowser_xoffset(pObject) -> num. 11839 11840 Returns the current horizontal offset from left in pixel of a 11841 formbrowser. 11842 11843 @param pObject : pointer to formbrowser object 11844 """ 11845 11846 _fl_get_formbrowser_xoffset = cfuncproto( 11847 load_so_libforms(), "fl_get_formbrowser_xoffset", 11848 cty.c_int, [cty.POINTER(FL_OBJECT)], 11849 """int fl_get_formbrowser_xoffset(FL_OBJECT * ob) 11850 """) 11851 keep_elem_refs(pObject) 11852 retval = _fl_get_formbrowser_xoffset(pObject) 11853 return retval
11854 11855
11856 -def fl_get_formbrowser_yoffset(pObject):
11857 """ 11858 fl_get_formbrowser_yoffset(pObject) -> num. 11859 11860 Returns the current vertical offset from top in pixel of a 11861 formbrowser. 11862 11863 @param pObject : pointer to formbrowser object 11864 """ 11865 11866 _fl_get_formbrowser_yoffset = cfuncproto( 11867 load_so_libforms(), "fl_get_formbrowser_yoffset", 11868 cty.c_int, [cty.POINTER(FL_OBJECT)], 11869 """int fl_get_formbrowser_yoffset(FL_OBJECT * ob) 11870 """) 11871 keep_elem_refs(pObject) 11872 retval = _fl_get_formbrowser_yoffset(pObject) 11873 return retval
11874 11875
11876 -def fl_find_formbrowser_form_number(pObject, pFormCandidate):
11877 """ fl_find_formbrowser_form_number(pObject, pFormCandidate) -> num. 11878 """ 11879 11880 _fl_find_formbrowser_form_number = cfuncproto( 11881 load_so_libforms(), "fl_find_formbrowser_form_number", 11882 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 11883 """int fl_find_formbrowser_form_number(FL_OBJECT * ob, 11884 FL_FORM * candidate_form) 11885 """) 11886 keep_elem_refs(pObject, pFormCandidate) 11887 retval = _fl_find_formbrowser_form_number(pObject, pFormCandidate) 11888 return retval
11889 11890
11891 -def fl_add_formbrowser(frmbrwstype, x, y, w, h, label):
11892 """ fl_add_formbrowser(frmbrwstype, x, y, w, h, label) -> pObject 11893 """ 11894 11895 _fl_add_formbrowser = cfuncproto( 11896 load_so_libforms(), "fl_add_formbrowser", 11897 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, 11898 FL_Coord, FL_Coord, STRING], 11899 """FL_OBJECT * fl_add_formbrowser(int type, FL_Coord x, 11900 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 11901 """) 11902 check_admitted_listvalues(frmbrwstype, FORMBRWSTYPE_list) 11903 ifrmbrwstype = convert_to_int(frmbrwstype) 11904 ix = convert_to_FL_Coord(x) 11905 iy = convert_to_FL_Coord(y) 11906 iw = convert_to_FL_Coord(w) 11907 ih = convert_to_FL_Coord(h) 11908 slabel = convert_to_string(label) 11909 keep_elem_refs(frmbrwstype, x, y, w, h, label, ifrmbrwstype, ix, iy, 11910 iw, ih, slabel) 11911 retval = _fl_add_formbrowser(ifrmbrwstype, ix, iy, iw, ih, slabel) 11912 return retval
11913 11914
11915 -def fl_create_formbrowser(frmbrwstype, x, y, w, h, label):
11916 """ fl_create_formbrowser(frmbrwstype, x, y, w, h, label) -> pObject 11917 """ 11918 11919 _fl_create_formbrowser = cfuncproto( 11920 load_so_libforms(), "fl_create_formbrowser", 11921 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, 11922 FL_Coord, FL_Coord, STRING], 11923 """FL_OBJECT * fl_create_formbrowser(int type, FL_Coord x, 11924 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 11925 """) 11926 check_admitted_listvalues(frmbrwstype, FORMBRWSTYPE_list) 11927 ifrmbrwstype = convert_to_int(frmbrwstype) 11928 ix = convert_to_FL_Coord(x) 11929 iy = convert_to_FL_Coord(y) 11930 iw = convert_to_FL_Coord(w) 11931 ih = convert_to_FL_Coord(h) 11932 slabel = convert_to_string(label) 11933 keep_elem_refs(frmbrwstype, x, y, w, h, label, ifrmbrwstype, ix, iy, 11934 iw, ih, slabel) 11935 retval = _fl_create_formbrowser(ifrmbrwstype, ix, iy, iw, ih, slabel) 11936 return retval
11937 11938
11939 -def fl_get_formbrowser_numforms(pObject):
11940 """ fl_get_formbrowser_numforms(pObject) -> forms num. 11941 """ 11942 11943 _fl_get_formbrowser_numforms = cfuncproto( 11944 load_so_libforms(), "fl_get_formbrowser_numforms", 11945 cty.c_int, [cty.POINTER(FL_OBJECT)], 11946 """int fl_get_formbrowser_numforms(FL_OBJECT * ob) 11947 """) 11948 keep_elem_refs(pObject) 11949 retval = _fl_get_formbrowser_numforms(pObject) 11950 return retval
11951 11952
11953 -def fl_get_formbrowser_form(pObject, n):
11954 """ fl_get_formbrowser_form(pObject, n) -> pForm 11955 """ 11956 11957 _fl_get_formbrowser_form = cfuncproto( 11958 load_so_libforms(), "fl_get_formbrowser_form", 11959 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 11960 """FL_FORM * fl_get_formbrowser_form(FL_OBJECT * ob, int n) 11961 """) 11962 inum = convert_to_int(n) 11963 keep_elem_refs(pObject, n, inum) 11964 retval = _fl_get_formbrowser_form(pObject, inum) 11965 return retval
11966 11967 11968 11969 #################### 11970 # forms.h (frame.h) 11971 #################### 11972
11973 -def fl_create_frame(frametype, x, y, w, h, label):
11974 """ fl_create_frame(frametype, x, y, w, h, label) -> pObject 11975 """ 11976 11977 _fl_create_frame = cfuncproto( 11978 load_so_libforms(), "fl_create_frame", 11979 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 11980 FL_Coord, STRING], 11981 """FL_OBJECT * fl_create_frame(int type, FL_Coord x, FL_Coord y, 11982 FL_Coord w, FL_Coord h, const char * label) 11983 """) 11984 check_admitted_listvalues(frametype, FRAMETYPE_list) 11985 iframetype = convert_to_int(frametype) 11986 ix = convert_to_FL_Coord(x) 11987 iy = convert_to_FL_Coord(y) 11988 iw = convert_to_FL_Coord(w) 11989 ih = convert_to_FL_Coord(h) 11990 slabel = convert_to_string(label) 11991 keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 11992 iw, ih, slabel) 11993 retval = _fl_create_frame(iframetype, ix, iy, iw, ih, slabel) 11994 return retval
11995 11996
11997 -def fl_add_frame(frametype, x, y, w, h, label):
11998 """ fl_add_frame(frametype, x, y, w, h, label) -> pObject 11999 """ 12000 12001 _fl_add_frame = cfuncproto( 12002 load_so_libforms(), "fl_add_frame", 12003 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 12004 FL_Coord, STRING], 12005 """FL_OBJECT * fl_add_frame(int type, FL_Coord x, FL_Coord y, 12006 FL_Coord w, FL_Coord h, const char * label) 12007 """) 12008 check_admitted_listvalues(frametype, FRAMETYPE_list) 12009 iframetype = convert_to_int(frametype) 12010 ix = convert_to_FL_Coord(x) 12011 iy = convert_to_FL_Coord(y) 12012 iw = convert_to_FL_Coord(w) 12013 ih = convert_to_FL_Coord(h) 12014 slabel = convert_to_string(label) 12015 keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 12016 iw, ih, slabel) 12017 retval = _fl_add_frame(iframetype, ix, iy, iw, ih, slabel) 12018 return retval
12019 12020 12021 # labeld frame 12022
12023 -def fl_create_labelframe(frametype, x, y, w, h, label):
12024 """ fl_create_labelframe(frametype, x, y, w, h, label) -> pObject 12025 """ 12026 12027 _fl_create_labelframe = cfuncproto( 12028 load_so_libforms(), "fl_create_labelframe", 12029 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 12030 FL_Coord, STRING], 12031 """FL_OBJECT * fl_create_labelframe(int type, FL_Coord x, 12032 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 12033 """) 12034 iframetype = convert_to_int(frametype) 12035 ix = convert_to_FL_Coord(x) 12036 iy = convert_to_FL_Coord(y) 12037 iw = convert_to_FL_Coord(w) 12038 ih = convert_to_FL_Coord(h) 12039 slabel = convert_to_string(label) 12040 keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 12041 iw, ih, slabel) 12042 retval = _fl_create_labelframe(iframetype, ix, iy, iw, ih, slabel) 12043 return retval
12044 12045
12046 -def fl_add_labelframe(frametype, x, y, w, h, label):
12047 """ fl_add_labelframe(frametype, x, y, w, h, label) -> pObject 12048 """ 12049 12050 _fl_add_labelframe = cfuncproto( 12051 load_so_libforms(), "fl_add_labelframe", 12052 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 12053 FL_Coord, STRING], 12054 """FL_OBJECT * fl_add_labelframe(int type, FL_Coord x, FL_Coord y, 12055 FL_Coord w, FL_Coord h, const char * label) 12056 """) 12057 iframetype = convert_to_int(frametype) 12058 ix = convert_to_FL_Coord(x) 12059 iy = convert_to_FL_Coord(y) 12060 iw = convert_to_FL_Coord(w) 12061 ih = convert_to_FL_Coord(h) 12062 slabel = convert_to_string(label) 12063 keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 12064 iw, ih, slabel) 12065 retval = _fl_add_labelframe(iframetype, ix, iy, iw, ih, slabel) 12066 return retval
12067 12068 12069 12070 ##################### 12071 # forms.h (free.h) 12072 # Object Class: Free 12073 ##################### 12074
12075 -def fl_create_free(freetype, x, y, w, h, label, py_HandlePtr):
12076 """ fl_create_free(freetype, x, y, w, h, label, py_HandlePtr) -> pObject 12077 """ 12078 12079 _fl_create_free = cfuncproto( 12080 load_so_libforms(), "fl_create_free", 12081 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 12082 FL_Coord, STRING, FL_HANDLEPTR], 12083 """FL_OBJECT * fl_create_free(int type, FL_Coord x, FL_Coord y, 12084 FL_Coord w, FL_Coord h, const char * label, 12085 FL_HANDLEPTR handle) 12086 """) 12087 check_admitted_listvalues(freetype, FREETYPE_list) 12088 ifreetype = convert_to_int(freetype) 12089 ix = convert_to_FL_Coord(x) 12090 iy = convert_to_FL_Coord(y) 12091 iw = convert_to_FL_Coord(w) 12092 ih = convert_to_FL_Coord(h) 12093 slabel = convert_to_string(label) 12094 c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 12095 keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 12096 keep_elem_refs(freetype, x, y, w, h, label, ifreetype, ix, iy, iw, ih, 12097 slabel) 12098 retval = _fl_create_free(ifreetype, ix, iy, iw, ih, slabel, c_HandlePtr) 12099 return retval
12100 12101
12102 -def fl_add_free(freetype, x, y, w, h, label, py_HandlePtr):
12103 """ fl_add_free(freetype, x, y, w, h, label, py_HandlePtr) -> pObject 12104 """ 12105 12106 _fl_add_free = cfuncproto( 12107 load_so_libforms(), "fl_add_free", 12108 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 12109 FL_Coord, STRING, FL_HANDLEPTR], 12110 """FL_OBJECT * fl_add_free(int type, FL_Coord x, FL_Coord y, 12111 FL_Coord w, FL_Coord h, const char * label, 12112 FL_HANDLEPTR handle) 12113 """) 12114 check_admitted_listvalues(freetype, FREETYPE_list) 12115 ifreetype = convert_to_int(freetype) 12116 ix = convert_to_FL_Coord(x) 12117 iy = convert_to_FL_Coord(y) 12118 iw = convert_to_FL_Coord(w) 12119 ih = convert_to_FL_Coord(h) 12120 slabel = convert_to_string(label) 12121 c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 12122 keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 12123 keep_elem_refs(freetype, x, y, w, h, label, ifreetype, ix, iy, iw, ih, 12124 slabel) 12125 retval = _fl_add_free(ifreetype, ix, iy, iw, ih, slabel, c_HandlePtr) 12126 return retval
12127 12128 12129 12130 ###################### 12131 # forms.h (goodies.h) 12132 ###################### 12133 12134 # Resources and misc. goodie routines 12135
12136 -def fl_set_goodies_font(style, size):
12137 """ fl_set_goodies_font(style, size) 12138 """ 12139 12140 _fl_set_goodies_font = cfuncproto( 12141 load_so_libforms(), "fl_set_goodies_font", 12142 None, [cty.c_int, cty.c_int], 12143 """void fl_set_goodies_font(int style, int size) 12144 """) 12145 istyle = convert_to_int(style) 12146 isize = convert_to_int(size) 12147 keep_elem_refs(style, size, istyle, isize) 12148 _fl_set_goodies_font(istyle, isize)
12149 12150 12151 # messages and questions 12152
12153 -def fl_show_message(msgtxt1, msgtxt2, msgtxt3):
12154 """ 12155 fl_show_message(msgtxt1, msgtxt2, msgtxt3) 12156 12157 Shows a message. 12158 12159 @param msgtxt1 : first message to show 12160 @param msgtxt2 : second message to show 12161 @param msgtxt3 : third message to show 12162 """ 12163 12164 _fl_show_message = cfuncproto( 12165 load_so_libforms(), "fl_show_message", 12166 None, [STRING, STRING, STRING], 12167 """void fl_show_message(const char * p1, const char * p2, 12168 const char * p3) 12169 """) 12170 smsgtxt1 = convert_to_string(msgtxt1) 12171 smsgtxt2 = convert_to_string(msgtxt2) 12172 smsgtxt3 = convert_to_string(msgtxt3) 12173 keep_elem_refs(msgtxt1, msgtxt2, msgtxt3, smsgtxt1, smsgtxt2, smsgtxt3) 12174 _fl_show_message(smsgtxt1, smsgtxt2, smsgtxt3)
12175 12176
12177 -def fl_show_messages(p1):
12178 """ fl_show_messages(p1) 12179 """ 12180 12181 _fl_show_messages = cfuncproto( 12182 load_so_libforms(), "fl_show_messages", 12183 None, [STRING], 12184 """void fl_show_messages(const char * p1) 12185 """) 12186 sp1 = convert_to_string(p1) 12187 keep_elem_refs(p1, sp1) 12188 _fl_show_messages(sp1)
12189 12190
12191 -def fl_show_msg(fmttxt):
12192 """ 12193 fl_show_msg(fmttxt) 12194 12195 Shows a text message. 12196 12197 @param fmttxt : text message to show (with format parameters, e.g. 12198 %s, %d, %f etc..) 12199 """ 12200 12201 _fl_show_msg = cfuncproto( 12202 load_so_libforms(), "fl_show_msg", 12203 None, [STRING], 12204 """void fl_show_msg(const char * p1) 12205 """) 12206 sfmttxt = convert_to_string(fmttxt) 12207 keep_elem_refs(fmttxt, sfmttxt) 12208 _fl_show_msg(sfmttxt)
12209 12210
12211 -def fl_hide_message():
12212 """ 12213 fl_hide_message() 12214 12215 Hides a text message already shown. 12216 """ 12217 12218 _fl_hide_message = cfuncproto( 12219 load_so_libforms(), "fl_hide_message", 12220 None, [], 12221 """void fl_hide_message() 12222 """) 12223 _fl_hide_message()
12224 12225 12226 fl_hide_msg = fl_hide_message 12227 fl_hide_messages = fl_hide_message 12228 12229
12230 -def fl_show_question(questmsg, p2):
12231 """ 12232 fl_show_question(questmsg, p2) -> num. 12233 12234 Shows a question message. 12235 12236 @param questmsg : text of question message to show 12237 @param p2 : ? 12238 """ 12239 12240 _fl_show_question = cfuncproto( 12241 load_so_libforms(), "fl_show_question", 12242 cty.c_int, [STRING, cty.c_int], 12243 """int fl_show_question(const char * p1, int p2) 12244 """) 12245 squestmsg = convert_to_string(questmsg) 12246 ip2 = convert_to_int(p2) 12247 keep_elem_refs(questmsg, p2, squestmsg, ip2) 12248 retval = _fl_show_question(squestmsg, ip2) 12249 return retval
12250 12251
12252 -def fl_hide_question():
12253 """ 12254 fl_hide_question() 12255 12256 Hides a question message already shown. 12257 """ 12258 12259 _fl_hide_question = cfuncproto( 12260 load_so_libforms(), "fl_hide_question", 12261 None, [], 12262 """void fl_hide_question() 12263 """) 12264 _fl_hide_question()
12265 12266
12267 -def fl_show_alert(p1, p2, p3, p4):
12268 """ fl_show_alert(p1, p2, p3, p4) 12269 """ 12270 12271 _fl_show_alert = cfuncproto( 12272 load_so_libforms(), "fl_show_alert", 12273 None, [STRING, STRING, STRING, cty.c_int], 12274 """void fl_show_alert(const char * p1, const char * p2, 12275 const char * p3, int p4) 12276 """) 12277 sp1 = convert_to_string(p1) 12278 sp2 = convert_to_string(p2) 12279 sp3 = convert_to_string(p3) 12280 ip4 = convert_to_int(p4) 12281 keep_elem_refs(p1, p2, p3, p4, sp1, sp2, sp3, ip4) 12282 _fl_show_alert(sp1, sp2, sp3, ip4)
12283 12284
12285 -def fl_show_alert2(c, fmt):
12286 """ fl_show_alert2(c, fmt) 12287 """ 12288 12289 _fl_show_alert2 = cfuncproto( 12290 load_so_libforms(), "fl_show_alert2", 12291 None, [cty.c_int, STRING], 12292 """void fl_show_alert2(int c, const char * fmt) 12293 """) 12294 ic = convert_to_int(c) 12295 sfmt = convert_to_string(fmt) 12296 keep_elem_refs(c, fmt, ic, sfmt) 12297 _fl_show_alert2(ic, sfmt)
12298 12299
12300 -def fl_hide_alert():
12301 """ fl_hide_alert() 12302 """ 12303 12304 _fl_hide_alert = cfuncproto( 12305 load_so_libforms(), "fl_hide_alert", 12306 None, [], 12307 """void fl_hide_alert() 12308 """) 12309 _fl_hide_alert()
12310 12311
12312 -def fl_show_input(p1, p2):
12313 """ fl_show_input(p1, p2) -> input string 12314 """ 12315 12316 _fl_show_input = cfuncproto( 12317 load_so_libforms(), "fl_show_input", 12318 STRING, [STRING, STRING], 12319 """const char * fl_show_input(const char * p1, const char * p2) 12320 """) 12321 sp1 = convert_to_string(p1) 12322 sp2 = convert_to_string(p2) 12323 keep_elem_refs(p1, p2, sp1, sp2) 12324 retval = _fl_show_input(sp1, sp2) 12325 return retval
12326 12327
12328 -def fl_hide_input():
12329 """ fl_hide_input() 12330 """ 12331 12332 _fl_hide_input = cfuncproto( 12333 load_so_libforms(), "fl_hide_input", 12334 None, [], 12335 """void fl_hide_input() 12336 """) 12337 _fl_hide_input()
12338 12339
12340 -def fl_show_simple_input(msgtxt, defstr):
12341 """ 12342 fl_show_simple_input(msgtxt, defstr) -> input string 12343 12344 Asks the user for textual input. 12345 12346 @param msgtxt : text message 12347 @param defstr : default user answer in input 12348 """ 12349 12350 _fl_show_simple_input = cfuncproto( 12351 load_so_libforms(), "fl_show_simple_input", 12352 STRING, [STRING, STRING], 12353 """const char * fl_show_simple_input(const char * p1, 12354 const char * p2) 12355 """) 12356 smsgtxt = convert_to_string(msgtxt) 12357 sdefstr = convert_to_string(defstr) 12358 keep_elem_refs(msgtxt, defstr, smsgtxt, sdefstr) 12359 retval = _fl_show_simple_input(smsgtxt, sdefstr) 12360 return retval
12361 12362
12363 -def fl_show_colormap(oldcolr):
12364 """ fl_show_colormap(oldcolr) -> colormap num. 12365 Shows a colormap color selector from which the user can select a color. 12366 <oldcolr> : color num. 12367 """ 12368 12369 _fl_show_colormap = cfuncproto( 12370 load_so_libforms(), "fl_show_colormap", 12371 cty.c_int, [cty.c_int], 12372 """int fl_show_colormap(int p1) 12373 """) 12374 ioldcolr = convert_to_int(oldcolr) 12375 keep_elem_refs(oldcolr, ioldcolr) 12376 retval = _fl_show_colormap(ioldcolr) 12377 return retval
12378 12379 12380 # choices 12381
12382 -def fl_show_choices(p1, p2, p3, p4, p5, p6):
12383 """ fl_show_choices(p1, p2, p3, p4, p5, p6) -> num. 12384 """ 12385 12386 _fl_show_choices = cfuncproto( 12387 load_so_libforms(), "fl_show_choices", 12388 cty.c_int, [STRING, cty.c_int, STRING, STRING, STRING, 12389 cty.c_int], 12390 """int fl_show_choices(const char * p1, int p2, 12391 const char * p3, const char * p4, const char * p5, int p6) 12392 """) 12393 sp1 = convert_to_string(p1) 12394 ip2 = convert_to_int(p2) 12395 sp3 = convert_to_string(p3) 12396 sp4 = convert_to_string(p4) 12397 sp5 = convert_to_string(p5) 12398 ip6 = convert_to_int(p6) 12399 keep_elem_refs(p1, p2, p3, p4, p5, p6, sp1, ip2, sp3, sp4, sp5, ip6) 12400 retval = _fl_show_choices(sp1, ip2, sp3, sp4, sp5, ip6) 12401 return retval
12402 12403
12404 -def fl_show_choice(p1, p2, p3, p4, p5, p6, p7, p8):
12405 """ fl_show_choice(p1, p2, p3, p4, p5, p6, p7, p8) -> num. 12406 """ 12407 12408 _fl_show_choice = cfuncproto( 12409 load_so_libforms(), "fl_show_choice", 12410 cty.c_int, [STRING, STRING, STRING, cty.c_int, STRING, STRING, 12411 STRING, cty.c_int], 12412 """int fl_show_choice(const char * p1, const char * p2, 12413 const char * p3, int p4, const char * p5, const char * p6, 12414 const char * p7, int p8) 12415 """) 12416 sp1 = convert_to_string(p1) 12417 sp2 = convert_to_string(p2) 12418 sp3 = convert_to_string(p3) 12419 ip4 = convert_to_int(p4) 12420 sp5 = convert_to_string(p5) 12421 sp6 = convert_to_string(p6) 12422 sp7 = convert_to_string(p7) 12423 ip8 = convert_to_int(p8) 12424 keep_elem_refs(sp1, sp2, sp3, ip4, sp5, sp6, sp7, ip8) 12425 retval = _fl_show_choice(sp1, sp2, sp3, ip4, sp5, sp6, sp7, ip8) 12426 return retval
12427 12428
12429 -def fl_hide_choice():
12430 """ fl_hide_choice() 12431 """ 12432 12433 _fl_hide_choice = cfuncproto( 12434 load_so_libforms(), "fl_hide_choice", 12435 None, [], 12436 """void fl_hide_choice() 12437 """) 12438 _fl_hide_choice()
12439 12440
12441 -def fl_set_choices_shortcut(p1, p2, p3):
12442 """ fl_set_choices_shortcut(p1, p2, p3) 12443 """ 12444 12445 _fl_set_choices_shortcut = cfuncproto( 12446 load_so_libforms(), "fl_set_choices_shortcut", 12447 None, [STRING, STRING, STRING], 12448 """void fl_set_choices_shortcut(const char * p1, const char * p2, 12449 const char * p3) 12450 """) 12451 sp1 = convert_to_string(p1) 12452 sp2 = convert_to_string(p2) 12453 sp3 = convert_to_string(p3) 12454 keep_elem_refs(p1, p2, p3, sp1, sp2, sp3) 12455 _fl_set_choices_shortcut(sp1, sp2, sp3)
12456 12457 12458 fl_set_choice_shortcut = fl_set_choices_shortcut 12459 12460 12461 # one liner 12462
12463 -def fl_show_oneliner(p1, p2, p3):
12464 """ fl_show_oneliner(p1, p2, p3) 12465 """ 12466 12467 _fl_show_oneliner = cfuncproto( 12468 load_so_libforms(), "fl_show_oneliner", 12469 None, [STRING, FL_Coord, FL_Coord], 12470 """void fl_show_oneliner(const char * p1, FL_Coord p2, 12471 FL_Coord p3) 12472 """) 12473 sp1 = convert_to_string(p1) 12474 ip2 = convert_to_FL_Coord(p2) 12475 ip3 = convert_to_FL_Coord(p3) 12476 keep_elem_refs(p1, p2, p3, sp1, ip2, ip3) 12477 _fl_show_oneliner(sp1, ip2, ip3)
12478 12479
12480 -def fl_hide_oneliner():
12481 """ fl_hide_oneliner() 12482 """ 12483 12484 _fl_hide_oneliner = cfuncproto( 12485 load_so_libforms(), "fl_hide_oneliner", 12486 None, [], 12487 """void fl_hide_oneliner() 12488 """) 12489 _fl_hide_oneliner()
12490 12491
12492 -def fl_set_oneliner_font(p1, p2):
12493 """ fl_set_oneliner_font(p1, p2) 12494 """ 12495 12496 _fl_set_oneliner_font = cfuncproto( 12497 load_so_libforms(), "fl_set_oneliner_font", 12498 None, [cty.c_int, cty.c_int], 12499 """void fl_set_oneliner_font(int p1, int p2) 12500 """) 12501 ip1 = convert_to_int(p1) 12502 ip2 = convert_to_int(p2) 12503 keep_elem_refs(p1, p2, ip1, ip2) 12504 _fl_set_oneliner_font(ip1, ip2)
12505 12506
12507 -def fl_set_oneliner_color(p1, p2):
12508 """ fl_set_oneliner_color(p1, p2) 12509 """ 12510 12511 _fl_set_oneliner_color = cfuncproto( 12512 load_so_libforms(), "fl_set_oneliner_color", 12513 None, [FL_COLOR, FL_COLOR], 12514 """void fl_set_oneliner_color(FL_COLOR p1, FL_COLOR p2) 12515 """) 12516 ulp1 = convert_to_FL_COLOR(p1) 12517 ulp2 = convert_to_FL_COLOR(p2) 12518 keep_elem_refs(p1, p2, ulp1, ulp2) 12519 _fl_set_oneliner_color(ulp1, ulp2)
12520 12521
12522 -def fl_set_tooltip_font(p1, p2):
12523 """ fl_set_tooltip_font(p1, p2) 12524 """ 12525 12526 _fl_set_tooltip_font = cfuncproto( 12527 load_so_libforms(), "fl_set_tooltip_font", 12528 None, [cty.c_int, cty.c_int], 12529 """void fl_set_tooltip_font(int p1, int p2) 12530 """) 12531 ip1 = convert_to_int(p1) 12532 ip2 = convert_to_int(p2) 12533 keep_elem_refs(p1, p2, ip1, ip2) 12534 _fl_set_tooltip_font(ip1, ip2)
12535 12536
12537 -def fl_set_tooltip_color(p1, p2):
12538 """ fl_set_tooltip_color(p1, p2) 12539 """ 12540 12541 _fl_set_tooltip_color = cfuncproto( 12542 load_so_libforms(), "fl_set_tooltip_color", 12543 None, [FL_COLOR, FL_COLOR], 12544 """void fl_set_tooltip_color(FL_COLOR p1, FL_COLOR p2) 12545 """) 12546 ulp1 = convert_to_FL_COLOR(p1) 12547 ulp2 = convert_to_FL_COLOR(p2) 12548 keep_elem_refs(p1, p2, ulp1, ulp2) 12549 _fl_set_tooltip_color(ulp1, ulp2)
12550 12551
12552 -def fl_set_tooltip_boxtype(p1):
12553 """ fl_set_tooltip_boxtype(p1) 12554 """ 12555 12556 _fl_set_tooltip_boxtype = cfuncproto( 12557 load_so_libforms(), "fl_set_tooltip_boxtype", 12558 None, [cty.c_int], 12559 """void fl_set_tooltip_boxtype(int p1) 12560 """) 12561 ip1 = convert_to_int(p1) 12562 keep_elem_refs(p1, ip1) 12563 _fl_set_tooltip_boxtype(ip1)
12564 12565
12566 -def fl_set_tooltip_lalign(p1):
12567 """ fl_set_tooltip_lalign(p1) 12568 """ 12569 12570 _fl_set_tooltip_lalign = cfuncproto( 12571 load_so_libforms(), "fl_set_tooltip_lalign", 12572 None, [cty.c_int], 12573 """void fl_set_tooltip_lalign(int p1) 12574 """) 12575 ip1 = convert_to_int(p1) 12576 keep_elem_refs(p1, ip1) 12577 _fl_set_tooltip_lalign(ip1)
12578 12579
12580 -def fl_exe_command(p1, p2):
12581 """ fl_exe_command(p1, p2) -> num. 12582 """ 12583 12584 _fl_exe_command = cfuncproto( 12585 load_so_libforms(), "fl_exe_command", 12586 cty.c_long, [STRING, cty.c_int], 12587 """long int fl_exe_command(const char * p1, int p2) 12588 """) 12589 sp1 = convert_to_string(p1) 12590 ip2 = convert_to_int(p2) 12591 keep_elem_refs(p1, sp1, p2, ip2) 12592 retval = _fl_exe_command(sp1, ip2) 12593 return retval
12594 12595
12596 -def fl_end_command(p1):
12597 """ fl_end_command(p1) -> num. 12598 """ 12599 12600 _fl_end_command = cfuncproto( 12601 load_so_libforms(), "fl_end_command", 12602 cty.c_int, [cty.c_long], 12603 """int fl_end_command(long int p1) 12604 """) 12605 lp1 = convert_to_long(p1) 12606 keep_elem_refs(p1, lp1) 12607 retval = _fl_end_command(lp1) 12608 return retval
12609 12610
12611 -def fl_check_command(p1):
12612 """ fl_check_command(p1) -> num. 12613 """ 12614 12615 _fl_check_command = cfuncproto( 12616 load_so_libforms(), "fl_check_command", 12617 cty.c_int, [cty.c_long], 12618 """int fl_check_command(long int p1) 12619 """) 12620 lp1 = convert_to_long(p1) 12621 keep_elem_refs(p1, lp1) 12622 retval = _fl_check_command(lp1) 12623 return retval
12624 12625
12626 -def fl_popen(p1, p2):
12627 """ fl_popen(p1, p2) -> FILE ptr. 12628 """ 12629 12630 _fl_popen = cfuncproto( 12631 load_so_libforms(), "fl_popen", 12632 cty.POINTER(FILE), [STRING, STRING], 12633 """FILE * fl_popen(const char * p1, const char * p2) 12634 """) 12635 sp1 = convert_to_string(p1) 12636 sp2 = convert_to_string(p2) 12637 keep_elem_refs(p1, p2, sp1, sp2) 12638 retval = _fl_popen(sp1, sp2) 12639 return retval
12640 12641
12642 -def fl_pclose(p1):
12643 """ fl_pclose(p1) -> num. 12644 """ 12645 12646 _fl_pclose = cfuncproto( 12647 load_so_libforms(), "fl_pclose", 12648 cty.c_int, [cty.POINTER(FILE)], 12649 """int fl_pclose(FILE * p1) 12650 """) 12651 keep_elem_refs(p1) 12652 retval = _fl_pclose(p1) 12653 return retval
12654 12655
12656 -def fl_end_all_command():
12657 """ fl_end_all_command() -> num. 12658 """ 12659 12660 _fl_end_all_command = cfuncproto( 12661 load_so_libforms(), "fl_end_all_command", 12662 cty.c_int, [], 12663 """int fl_end_all_command() 12664 """) 12665 retval = _fl_end_all_command() 12666 return retval
12667 12668
12669 -def fl_show_command_log(p1):
12670 """ fl_show_command_log(p1) 12671 """ 12672 12673 _fl_show_command_log = cfuncproto( 12674 load_so_libforms(), "fl_show_command_log", 12675 None, [cty.c_int], 12676 """void fl_show_command_log(int p1) 12677 """) 12678 ip1 = convert_to_int(p1) 12679 keep_elem_refs(p1, ip1) 12680 _fl_show_command_log(ip1)
12681 12682
12683 -def fl_hide_command_log():
12684 """ fl_hide_command_log() 12685 """ 12686 12687 _fl_hide_command_log = cfuncproto( 12688 load_so_libforms(), "fl_hide_command_log", 12689 None, [], 12690 """void fl_hide_command_log() 12691 """) 12692 _fl_hide_command_log()
12693 12694
12695 -def fl_clear_command_log():
12696 """ fl_clear_command_log() 12697 """ 12698 12699 _fl_clear_command_log = cfuncproto( 12700 load_so_libforms(), "fl_clear_command_log", 12701 None, [], 12702 """void fl_clear_command_log() 12703 """) 12704 _fl_clear_command_log()
12705 12706
12707 -def fl_addto_command_log(p1):
12708 """ fl_addto_command_log(p1) 12709 """ 12710 12711 _fl_addto_command_log = cfuncproto( 12712 load_so_libforms(), "fl_addto_command_log", 12713 None, [STRING], 12714 """void fl_addto_command_log(const char * p1) 12715 """) 12716 sp1 = convert_to_string(p1) 12717 keep_elem_refs(p1, sp1) 12718 _fl_addto_command_log(sp1)
12719 12720
12721 -def fl_set_command_log_position(p1, p2):
12722 """ fl_set_command_log_position(p1, p2) 12723 """ 12724 12725 _fl_set_command_log_position = cfuncproto( 12726 load_so_libforms(), "fl_set_command_log_position", 12727 None, [cty.c_int, cty.c_int], 12728 """void fl_set_command_log_position(int p1, int p2) 12729 """) 12730 ip1 = convert_to_int(p1) 12731 ip2 = convert_to_int(p2) 12732 keep_elem_refs(p1, p2, ip1, ip2) 12733 _fl_set_command_log_position(ip1, ip2)
12734 12735
12736 -def fl_get_command_log_fdstruct():
12737 """ fl_get_command_log_fdstruct() -> pCmdlog 12738 """ 12739 12740 _fl_get_command_log_fdstruct = cfuncproto( 12741 load_so_libforms(), "fl_get_command_log_fdstruct", 12742 cty.POINTER(FD_CMDLOG), [], 12743 """)FD_CMDLOG * fl_get_command_log_fdstruct() 12744 """) 12745 retval = _fl_get_command_log_fdstruct() 12746 return retval
12747 12748 12749 # aliases 12750 fl_open_command = fl_exe_command 12751 fl_close_command = fl_end_command 12752 12753 12754 # file selector 12755
12756 -def fl_use_fselector(p1):
12757 """ fl_use_fselector(p1) -> num. 12758 """ 12759 12760 _fl_use_fselector = cfuncproto( 12761 load_so_libforms(), "fl_use_fselector", 12762 cty.c_int, [cty.c_int], 12763 """int fl_use_fselector(int p1) 12764 """) 12765 ip1 = convert_to_int(p1) 12766 keep_elem_refs(p1, ip1) 12767 retval = _fl_use_fselector(ip1) 12768 return retval
12769 12770
12771 -def fl_show_fselector(p1, p2, p3, p4):
12772 """ fl_show_fselector(p1, p2, p3, p4) -> fselector string 12773 """ 12774 12775 _fl_show_fselector = cfuncproto( 12776 load_so_libforms(), "fl_show_fselector", 12777 STRING, [STRING, STRING, STRING, STRING], 12778 """const char * fl_show_fselector(const char * p1, 12779 const char * p2, const char * p3, const char * p4) 12780 """) 12781 sp1 = convert_to_string(p1) 12782 sp2 = convert_to_string(p2) 12783 sp3 = convert_to_string(p3) 12784 sp4 = convert_to_string(p4) 12785 keep_elem_refs(p1, p2, p3, p4, sp1, sp2, sp3, sp4) 12786 retval = _fl_show_fselector(sp1, sp2, sp3, sp4) 12787 return retval
12788 12789
12790 -def fl_set_fselector_fontsize(p1):
12791 """ fl_set_fselector_fontsize(p1) 12792 """ 12793 12794 _fl_set_fselector_fontsize = cfuncproto( 12795 load_so_libforms(), "fl_set_fselector_fontsize", 12796 None, [cty.c_int], 12797 """void fl_set_fselector_fontsize(int p1) 12798 """) 12799 ip1 = convert_to_int(p1) 12800 keep_elem_refs(p1, ip1) 12801 _fl_set_fselector_fontsize(ip1)
12802 12803
12804 -def fl_set_fselector_fontstyle(p1):
12805 """ fl_set_fselector_fontstyle(p1) 12806 """ 12807 12808 _fl_set_fselector_fontstyle = cfuncproto( 12809 load_so_libforms(), "fl_set_fselector_fontstyle", 12810 None, [cty.c_int], 12811 """void fl_set_fselector_fontstyle(int p1) 12812 """) 12813 ip1 = convert_to_int(p1) 12814 keep_elem_refs(p1, ip1) 12815 _fl_set_fselector_fontstyle(ip1)
12816 12817
12818 -def fl_set_fselector_placement(p1):
12819 """ fl_set_fselector_placement(p1) 12820 """ 12821 12822 _fl_set_fselector_placement = cfuncproto( 12823 load_so_libforms(), "fl_set_fselector_placement", 12824 None, [cty.c_int], 12825 """void fl_set_fselector_placement(int p1) 12826 """) 12827 ip1 = convert_to_int(p1) 12828 keep_elem_refs(p1, ip1) 12829 _fl_set_fselector_placement(ip1)
12830 12831
12832 -def fl_set_fselector_border(p1):
12833 """ fl_set_fselector_border(p1) 12834 """ 12835 12836 _fl_set_fselector_border = cfuncproto( 12837 load_so_libforms(), "fl_set_fselector_border", 12838 None, [cty.c_int], 12839 """void fl_set_fselector_border(int p1) 12840 """) 12841 ip1 = convert_to_int(p1) 12842 keep_elem_refs(p1, ip1) 12843 _fl_set_fselector_border(ip1)
12844 12845
12846 -def fl_set_fselector_transient(b):
12847 if b: 12848 argval = FL_TRANSIENT 12849 else: 12850 argval = FL_FULLBORDER 12851 fl_set_fselector_border(argval)
12852 12853 12854 FL_FSCB = cty.CFUNCTYPE(cty.c_int, STRING, cty.c_void_p) 12855
12856 -def fl_set_fselector_callback(py_FSCB, data):
12857 """ 12858 fl_set_fselector_callback(py_FSCB, data) 12859 """ 12860 12861 _fl_set_fselector_callback = cfuncproto( 12862 load_so_libforms(), "fl_set_fselector_callback", 12863 None, [FL_FSCB, cty.c_void_p], 12864 """void fl_set_fselector_callback(FL_FSCB p1, void * p2) 12865 """) 12866 c_FSCB = FL_FSCB(py_FSCB) 12867 pdata = cty.cast(data, cty.c_void_p) 12868 keep_cfunc_refs(c_FSCB, py_FSCB) 12869 keep_elem_refs(data, pdata) 12870 _fl_set_fselector_callback(c_FSCB, pdata)
12871 12872
12873 -def fl_get_filename():
12874 """ fl_get_filename() -> filename string 12875 """ 12876 12877 _fl_get_filename = cfuncproto( 12878 load_so_libforms(), "fl_get_filename", 12879 STRING, [], 12880 """const char * fl_get_filename() 12881 """) 12882 retval = _fl_get_filename() 12883 return retval
12884 12885
12886 -def fl_get_directory():
12887 """ fl_get_directory() -> directory string 12888 """ 12889 12890 _fl_get_directory = cfuncproto( 12891 load_so_libforms(), "fl_get_directory", 12892 STRING, [], 12893 """const char * fl_get_directory() 12894 """) 12895 retval = _fl_get_directory() 12896 return retval
12897 12898
12899 -def fl_get_pattern():
12900 """ fl_get_pattern() -> pattern string 12901 """ 12902 12903 _fl_get_pattern = cfuncproto( 12904 load_so_libforms(), "fl_get_pattern", 12905 STRING, [], 12906 """const char * fl_get_pattern() 12907 """) 12908 retval = _fl_get_pattern() 12909 return retval
12910 12911
12912 -def fl_set_directory(p1):
12913 """ fl_set_directory(p1) -> num. 12914 """ 12915 12916 _fl_set_directory = cfuncproto( 12917 load_so_libforms(), "fl_set_directory", 12918 cty.c_int, [STRING], 12919 """int fl_set_directory(const char * p1) 12920 """) 12921 sp1 = convert_to_string(p1) 12922 keep_elem_refs(p1, sp1) 12923 retval = _fl_set_directory(sp1) 12924 return retval
12925 12926
12927 -def fl_set_pattern(p1):
12928 """ fl_set_pattern(p1) 12929 """ 12930 12931 _fl_set_pattern = cfuncproto( 12932 load_so_libforms(), "fl_set_pattern", 12933 None, [STRING], 12934 """void fl_set_pattern(const char * p1) 12935 """) 12936 sp1 = convert_to_string(p1) 12937 keep_elem_refs(p1, sp1) 12938 _fl_set_pattern(sp1)
12939 12940
12941 -def fl_refresh_fselector():
12942 """ fl_refresh_fselector() 12943 """ 12944 12945 _fl_refresh_fselector = cfuncproto( 12946 load_so_libforms(), "fl_refresh_fselector", 12947 None, [], 12948 """void fl_refresh_fselector() 12949 """) 12950 _fl_refresh_fselector()
12951 12952 12953 # c function prototype for _fl_add_fselector_appbutton 12954 cfunc_none_voidp = cty.CFUNCTYPE(None, cty.c_void_p) 12955
12956 -def fl_add_fselector_appbutton(label, py_fn, data):
12957 """ fl_add_fselector_appbutton(label, py_fn, data) 12958 """ 12959 12960 _fl_add_fselector_appbutton = cfuncproto( 12961 load_so_libforms(), "fl_add_fselector_appbutton", 12962 None, [STRING, cfunc_none_voidp, cty.c_void_p], 12963 """void fl_add_fselector_appbutton(const char * p1, 12964 const char * p2, void * p3) 12965 """) 12966 slabel = convert_to_string(label) 12967 c_fn = cfunc_none_voidp(py_fn) 12968 pdata = cty.cast(data, cty.c_void_p) 12969 keep_cfunc_refs(c_fn, py_fn) 12970 keep_elem_refs(label, data, slabel, pdata) 12971 _fl_add_fselector_appbutton(slabel, c_fn, pdata)
12972 12973
12974 -def fl_remove_fselector_appbutton(label):
12975 """ fl_remove_fselector_appbutton(label) 12976 """ 12977 12978 _fl_remove_fselector_appbutton = cfuncproto( 12979 load_so_libforms(), "fl_remove_fselector_appbutton", 12980 None, [STRING], 12981 """void fl_remove_fselector_appbutton(const char * p1) 12982 """) 12983 slabel = convert_to_string(label) 12984 keep_elem_refs(label, slabel) 12985 _fl_remove_fselector_appbutton(slabel)
12986 12987
12988 -def fl_disable_fselector_cache(yes):
12989 """ fl_disable_fselector_cache(yes) 12990 """ 12991 12992 _fl_disable_fselector_cache = cfuncproto( 12993 load_so_libforms(), "fl_disable_fselector_cache", 12994 None, [cty.c_int], 12995 """void fl_disable_fselector_cache(int p1) 12996 """) 12997 iyes = convert_to_int(yes) 12998 keep_elem_refs(yes, iyes) 12999 _fl_disable_fselector_cache(iyes)
13000 13001
13002 -def fl_invalidate_fselector_cache():
13003 """ fl_invalidate_fselector_cache() 13004 """ 13005 13006 _fl_invalidate_fselector_cache = cfuncproto( 13007 load_so_libforms(), "fl_invalidate_fselector_cache", 13008 None, [], 13009 """void fl_invalidate_fselector_cache() 13010 """) 13011 _fl_invalidate_fselector_cache()
13012 13013
13014 -def fl_get_fselector_form():
13015 """ fl_get_fselector_form() -> pForm 13016 """ 13017 13018 _fl_get_fselector_form = cfuncproto( 13019 load_so_libforms(), "fl_get_fselector_form", 13020 cty.POINTER(FL_FORM), [], 13021 """FL_FORM * fl_get_fselector_form() 13022 """) 13023 retval = _fl_get_fselector_form() 13024 return retval
13025 13026
13027 -def fl_get_fselector_fdstruct():
13028 """ fl_get_fselector_fdstruct() -> fselector class 13029 """ 13030 13031 _fl_get_fselector_fdstruct = cfuncproto( 13032 load_so_libforms(), "fl_get_fselector_fdstruct", 13033 cty.POINTER(FD_FSELECTOR), [], 13034 """FD_FSELECTOR * fl_get_fselector_fdstruct() 13035 """) 13036 retval = _fl_get_fselector_fdstruct() 13037 return retval
13038 13039
13040 -def fl_hide_fselector():
13041 """ fl_hide_fselector() 13042 """ 13043 13044 _fl_hide_fselector = cfuncproto( 13045 load_so_libforms(), "fl_hide_fselector", 13046 None, [], 13047 """void fl_hide_fselector() 13048 """) 13049 _fl_hide_fselector()
13050 13051
13052 -def fl_set_fselector_filetype_marker(p1, p2, p3, p4, p5):
13053 """ fl_set_fselector_filetype_marker(p1, p2, p3, p4, p5) 13054 """ 13055 13056 _fl_set_fselector_filetype_marker = cfuncproto( 13057 load_so_libforms(), "fl_set_fselector_filetype_marker", 13058 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int], 13059 """void fl_set_fselector_filetype_marker(int p1, int p2, int p3, 13060 int p4, int p5) 13061 """) 13062 ip1 = convert_to_int(p1) 13063 ip2 = convert_to_int(p2) 13064 ip3 = convert_to_int(p3) 13065 ip4 = convert_to_int(p4) 13066 ip5 = convert_to_int(p5) 13067 keep_elem_refs(p1, p2, p3, p4, p5, ip1, ip2, ip3, ip4, ip5) 13068 _fl_set_fselector_filetype_marker(ip1, ip2, ip3, ip4, ip5)
13069 13070 13071 fl_show_file_selector = fl_show_fselector 13072 fl_set_fselector_cb = fl_set_fselector_callback 13073 13074
13075 -def fl_set_fselector_title(title):
13076 fl_set_form_title(fl_get_fselector_form(), title)
13077 13078
13079 -def fl_goodies_atclose(pForm, data):
13080 """ fl_goodies_atclose(pForm, data) -> num. 13081 """ 13082 13083 _fl_goodies_atclose = cfuncproto( 13084 load_so_libforms(), "fl_goodies_atclose", 13085 cty.c_int, [cty.POINTER(FL_FORM), cty.c_void_p], 13086 """int fl_goodies_atclose(FL_FORM * p1, void * p2) 13087 """) 13088 pdata = cty.cast(data, cty.c_void_p) 13089 keep_elem_refs(pForm, data, pdata) 13090 retval = _fl_goodies_atclose(pForm, pdata) 13091 return retval
13092 13093 13094 13095 #################### 13096 # forms.h (input.h) 13097 #################### 13098 13099 # Routines 13100
13101 -def fl_create_input(inputtype, x, y, w, h, label):
13102 """ fl_create_input(inputtype, x, y, w, h, label) -> pObject 13103 """ 13104 13105 _fl_create_input = cfuncproto( 13106 load_so_libforms(), "fl_create_input", 13107 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 13108 FL_Coord, STRING], 13109 """FL_OBJECT * fl_create_input(int type, FL_Coord x, FL_Coord y, 13110 FL_Coord w, FL_Coord h, const char * label) 13111 """) 13112 check_admitted_listvalues(inputtype, INPUTTYPE_list) 13113 iinputtype = convert_to_int(inputtype) 13114 ix = convert_to_FL_Coord(x) 13115 iy = convert_to_FL_Coord(y) 13116 iw = convert_to_FL_Coord(w) 13117 ih = convert_to_FL_Coord(h) 13118 slabel = convert_to_string(label) 13119 keep_elem_refs(inputtype, x, y, w, h, label, iinputtype, ix, iy, 13120 iw, ih, slabel) 13121 retval = _fl_create_input(iinputtype, ix, iy, iw, ih, slabel) 13122 return retval
13123 13124
13125 -def fl_add_input(inputtype, x, y, w, h, label):
13126 """ fl_add_input(inputtype, x, y, w, h, label) -> pObject 13127 """ 13128 13129 _fl_add_input = cfuncproto( 13130 load_so_libforms(), "fl_add_input", 13131 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 13132 FL_Coord, STRING], 13133 """FL_OBJECT * fl_add_input(int type, FL_Coord x, FL_Coord y, 13134 FL_Coord w, FL_Coord h, const char * label) 13135 """) 13136 check_admitted_listvalues(inputtype, INPUTTYPE_list) 13137 iinputtype = convert_to_int(inputtype) 13138 ix = convert_to_FL_Coord(x) 13139 iy = convert_to_FL_Coord(y) 13140 iw = convert_to_FL_Coord(w) 13141 ih = convert_to_FL_Coord(h) 13142 slabel = convert_to_string(label) 13143 keep_elem_refs(inputtype, x, y, w, h, label, iinputtype, ix, iy, 13144 iw, ih, slabel) 13145 retval = _fl_add_input(iinputtype, ix, iy, iw, ih, slabel) 13146 return retval
13147 13148
13149 -def fl_set_input(pObject, inputstr):
13150 """ fl_set_input(pObject, inputstr) 13151 """ 13152 13153 _fl_set_input = cfuncproto( 13154 load_so_libforms(), "fl_set_input", 13155 None, [cty.POINTER(FL_OBJECT), STRING], 13156 """void fl_set_input(FL_OBJECT * ob, const char * str) 13157 """) 13158 sinputstr = convert_to_string(inputstr) 13159 keep_elem_refs(pObject, inputstr, sinputstr) 13160 _fl_set_input(pObject, sinputstr)
13161 13162
13163 -def fl_set_input_return(pObject, value):
13164 """ fl_set_input_return(pObject, value) 13165 """ 13166 13167 _fl_set_input_return = cfuncproto( 13168 load_so_libforms(), "fl_set_input_return", 13169 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13170 """void fl_set_input_return(FL_OBJECT * ob, int value) 13171 """) 13172 ivalue = convert_to_int(value) 13173 keep_elem_refs(pObject, value, ivalue) 13174 _fl_set_input_return(pObject, ivalue)
13175 13176
13177 -def fl_set_input_color(pObject, textcolr, curscolr):
13178 """ fl_set_input_color(pObject, textcolr, curscolr) 13179 """ 13180 13181 _fl_set_input_color = cfuncproto( 13182 load_so_libforms(), "fl_set_input_color", 13183 None, [cty.POINTER(FL_OBJECT), FL_COLOR, FL_COLOR], 13184 """void fl_set_input_color(FL_OBJECT * ob, FL_COLOR textcol, 13185 FL_COLOR curscol) 13186 """) 13187 ultextcolr = convert_to_FL_COLOR(textcolr) 13188 ulcurscolr = convert_to_FL_COLOR(curscolr) 13189 keep_elem_refs(pObject, textcolr, curscolr, ultextcolr, ulcurscolr) 13190 _fl_set_input_color(pObject, ultextcolr, ulcurscolr)
13191 13192 13193 #def fl_get_input_color(pObject, textcolr, curscolr) *API change*
13194 -def fl_get_input_color(pObject):
13195 """ fl_get_input_color(pObject) -> textcolr, curscolr 13196 """ 13197 13198 _fl_get_input_color = cfuncproto( 13199 load_so_libforms(), "fl_get_input_color", 13200 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_COLOR), 13201 cty.POINTER(FL_COLOR)], 13202 """void fl_get_input_color(FL_OBJECT * ob, FL_COLOR * textcol, 13203 FL_COLOR * curscol) 13204 """) 13205 textcolr, ptextcolr = make_ulong_and_pointer() 13206 curscolr, pcurscolr = make_ulong_and_pointer() 13207 keep_elem_refs(pObject, textcolr, curscolr) 13208 _fl_get_input_color(pObject, ptextcolr, pcurscolr) 13209 return textcolr, curscolr
13210 13211
13212 -def fl_set_input_scroll(pObject, yes):
13213 """ fl_set_input_scroll(pObject, yes) 13214 """ 13215 13216 _fl_set_input_scroll = cfuncproto( 13217 load_so_libforms(), "fl_set_input_scroll", 13218 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13219 """void fl_set_input_scroll(FL_OBJECT * ob, int yes) 13220 """) 13221 iyes = convert_to_int(yes) 13222 keep_elem_refs(pObject, yes, iyes) 13223 _fl_set_input_scroll(pObject, iyes)
13224 13225
13226 -def fl_set_input_cursorpos(pObject, xpos, ypos):
13227 """ fl_set_input_cursorpos(pObject, xpos, ypos) 13228 """ 13229 13230 _fl_set_input_cursorpos = cfuncproto( 13231 load_so_libforms(), "fl_set_input_cursorpos", 13232 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 13233 """void fl_set_input_cursorpos(FL_OBJECT * ob, int xpos, int ypos) 13234 """) 13235 ixpos = convert_to_int(xpos) 13236 iypos = convert_to_int(ypos) 13237 keep_elem_refs(pObject, xpos, ypos, ixpos, iypos) 13238 _fl_set_input_cursorpos(pObject, ixpos, iypos)
13239 13240
13241 -def fl_set_input_selected(pObject, yes):
13242 """ fl_set_input_selected(pObject, yes) 13243 """ 13244 13245 _fl_set_input_selected = cfuncproto( 13246 load_so_libforms(), "fl_set_input_selected", 13247 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13248 """void fl_set_input_selected(FL_OBJECT * ob, int yes) 13249 """) 13250 iyes = convert_to_int(yes) 13251 keep_elem_refs(pObject, yes, iyes) 13252 _fl_set_input_selected(pObject, iyes)
13253 13254
13255 -def fl_set_input_selected_range(pObject, begin, end):
13256 """ fl_set_input_selected_range(pObject, begin, end) 13257 """ 13258 13259 _fl_set_input_selected_range = cfuncproto( 13260 load_so_libforms(), "fl_set_input_selected_range", 13261 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 13262 """void fl_set_input_selected_range(FL_OBJECT * ob, 13263 int begin, int end) 13264 """) 13265 ibegin = convert_to_int(begin) 13266 iend = convert_to_int(end) 13267 keep_elem_refs(pObject, begin, end, ibegin, iend) 13268 _fl_set_input_selected_range(pObject, ibegin, iend)
13269 13270 13271 #def fl_get_input_selected_range(pObject, begin, end) *API change*
13272 -def fl_get_input_selected_range(pObject):
13273 """ fl_get_input_selected_range(pObject) -> string, begin, end 13274 """ 13275 13276 _fl_get_input_selected_range = cfuncproto( 13277 load_so_libforms(), "fl_get_input_selected_range", 13278 STRING, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 13279 cty.POINTER(cty.c_int)], 13280 """const char * fl_get_input_selected_range(FL_OBJECT * ob, 13281 int * begin, int * end) 13282 """) 13283 begin, pbegin = make_int_and_pointer() 13284 end, pend = make_int_and_pointer() 13285 keep_elem_refs(pObject, begin, end, pbegin, pend) 13286 retval = _fl_get_input_selected_range(pObject, pbegin, pend) 13287 return retval, begin, end
13288 13289
13290 -def fl_set_input_maxchars(pObject, maxchars):
13291 """ fl_set_input_maxchars(pObject, maxchars) 13292 """ 13293 13294 _fl_set_input_maxchars = cfuncproto( 13295 load_so_libforms(), "fl_set_input_maxchars", 13296 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13297 """void fl_set_input_maxchars(FL_OBJECT * ob, int maxchars) 13298 """) 13299 imaxchars = convert_to_int(maxchars) 13300 keep_elem_refs(pObject, maxchars, imaxchars) 13301 _fl_set_input_maxchars(pObject, imaxchars)
13302 13303
13304 -def fl_set_input_format(pObject, fmt, sep):
13305 """ fl_set_input_format(pObject, fmt, sep) 13306 """ 13307 13308 _fl_set_input_format = cfuncproto( 13309 load_so_libforms(), "fl_set_input_format", 13310 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 13311 """void fl_set_input_format(FL_OBJECT * ob, int fmt, int sep) 13312 """) 13313 ifmt = convert_to_int(fmt) 13314 isep = convert_to_int(sep) 13315 keep_elem_refs(pObject, fmt, sep, ifmt, isep) 13316 _fl_set_input_format(pObject, ifmt, isep)
13317 13318
13319 -def fl_set_input_hscrollbar(pObject, pref):
13320 """ fl_set_input_hscrollbar(pObject, pref) 13321 """ 13322 13323 _fl_set_input_hscrollbar = cfuncproto( 13324 load_so_libforms(), "fl_set_input_hscrollbar", 13325 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13326 """void fl_set_input_hscrollbar(FL_OBJECT * ob, int pref) 13327 """) 13328 ipref = convert_to_int(pref) 13329 keep_elem_refs(pObject, pref, ipref) 13330 _fl_set_input_hscrollbar(pObject, ipref)
13331 13332
13333 -def fl_set_input_vscrollbar(pObject, pref):
13334 """ fl_set_input_vscrollbar(pObject, pref) 13335 """ 13336 13337 _fl_set_input_vscrollbar = cfuncproto( 13338 load_so_libforms(), "fl_set_input_vscrollbar", 13339 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13340 """void fl_set_input_vscrollbar(FL_OBJECT * ob, int pref) 13341 """) 13342 ipref = convert_to_int(pref) 13343 keep_elem_refs(pObject, pref, ipref) 13344 _fl_set_input_vscrollbar(pObject, ipref)
13345 13346
13347 -def fl_set_input_topline(pObject, top):
13348 """ fl_set_input_topline(pObject, top) 13349 """ 13350 13351 _fl_set_input_topline = cfuncproto( 13352 load_so_libforms(), "fl_set_input_topline", 13353 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13354 """void fl_set_input_topline(FL_OBJECT * ob, int top) 13355 """) 13356 itop = convert_to_int(top) 13357 keep_elem_refs(pObject, top, itop) 13358 _fl_set_input_topline(pObject, itop)
13359 13360
13361 -def fl_set_input_scrollbarsize(pObject, hh, vw):
13362 """ fl_set_input_scrollbarsize(pObject, hh, vw) 13363 """ 13364 13365 _fl_set_input_scrollbarsize = cfuncproto( 13366 load_so_libforms(), "fl_set_input_scrollbarsize", 13367 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 13368 """void fl_set_input_scrollbarsize(FL_OBJECT * ob, int hh, int vw) 13369 """) 13370 ihh = convert_to_int(hh) 13371 ivw = convert_to_int(vw) 13372 keep_elem_refs(pObject, hh, vw, ihh, ivw) 13373 _fl_set_input_scrollbarsize(pObject, ihh, ivw)
13374 13375 13376 #def fl_get_input_scrollbarsize(pObject, hh, vw) *API change*
13377 -def fl_get_input_scrollbarsize(pObject):
13378 """ fl_get_input_scrollbarsize(pObject) -> hh, vw 13379 """ 13380 13381 _fl_get_input_scrollbarsize = cfuncproto( 13382 load_so_libforms(), "fl_get_input_scrollbarsize", 13383 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 13384 cty.POINTER(cty.c_int)], 13385 """void fl_get_input_scrollbarsize(FL_OBJECT * ob, 13386 int * hh, int * vw) 13387 """) 13388 hh, phh = make_int_and_pointer() 13389 vw, pvw = make_int_and_pointer() 13390 keep_elem_refs(pObject, hh, vw) 13391 _fl_get_input_scrollbarsize(pObject, phh, pvw) 13392 return hh, vw
13393 13394
13395 -def fl_set_input_xoffset(pObject, xoff):
13396 """ fl_set_input_xoffset(pObject, xoff) 13397 """ 13398 13399 _fl_set_input_xoffset = cfuncproto( 13400 load_so_libforms(), "fl_set_input_xoffset", 13401 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13402 """void fl_set_input_xoffset(FL_OBJECT * ob, int xoff) 13403 """) 13404 ixoff = convert_to_int(xoff) 13405 keep_elem_refs(pObject, xoff, ixoff) 13406 _fl_set_input_xoffset(pObject, ixoff)
13407 13408
13409 -def fl_get_input_xoffset(pObject):
13410 """ fl_get_input_xoffset(pObject) -> num. 13411 """ 13412 13413 _fl_get_input_xoffset = cfuncproto( 13414 load_so_libforms(), "fl_get_input_xoffset", 13415 cty.c_int, [cty.POINTER(FL_OBJECT)], 13416 """int fl_get_input_xoffset(FL_OBJECT * ob) 13417 """) 13418 keep_elem_refs(pObject) 13419 retval = _fl_get_input_xoffset(pObject) 13420 return retval
13421 13422
13423 -def fl_set_input_fieldchar(pObject, fldchar):
13424 """ fl_set_input_fieldchar(pObject, fldchar) -> num. 13425 """ 13426 13427 _fl_set_input_fieldchar = cfuncproto( 13428 load_so_libforms(), "fl_set_input_fieldchar", 13429 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 13430 """int fl_set_input_fieldchar(FL_OBJECT * ob, int fchar) 13431 """) 13432 ifldchar = convert_to_int(fldchar) 13433 keep_elem_refs(pObject, fldchar, ifldchar) 13434 retval = _fl_set_input_fieldchar(pObject, ifldchar) 13435 return retval
13436 13437
13438 -def fl_get_input_topline(pObject):
13439 """ fl_get_input_topline(pObject) -> num. 13440 """ 13441 13442 _fl_get_input_topline = cfuncproto( 13443 load_so_libforms(), "fl_get_input_topline", 13444 cty.c_int, [cty.POINTER(FL_OBJECT)], 13445 """int fl_get_input_topline(FL_OBJECT * ob) 13446 """) 13447 keep_elem_refs(pObject) 13448 retval = _fl_get_input_topline(pObject) 13449 return retval
13450 13451
13452 -def fl_get_input_screenlines(pObject):
13453 """ fl_get_input_screenlines(pObject) -> num. 13454 """ 13455 13456 _fl_get_input_screenlines = cfuncproto( 13457 load_so_libforms(), "fl_get_input_screenlines", 13458 cty.c_int, [cty.POINTER(FL_OBJECT)], 13459 """int fl_get_input_screenlines(FL_OBJECT * ob) 13460 """) 13461 keep_elem_refs(pObject) 13462 retval = _fl_get_input_screenlines(pObject) 13463 return retval
13464 13465 13466 #def fl_get_input_cursorpos(pObject, x, y) *API change*
13467 -def fl_get_input_cursorpos(pObject):
13468 """ fl_get_input_cursorpos(pObject) -> num., x, y 13469 """ 13470 13471 _fl_get_input_cursorpos = cfuncproto( 13472 load_so_libforms(), "fl_get_input_cursorpos", 13473 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 13474 cty.POINTER(cty.c_int)], 13475 """int fl_get_input_cursorpos(FL_OBJECT * ob, int * x, int * y) 13476 """) 13477 x, px = make_int_and_pointer() 13478 y, py = make_int_and_pointer() 13479 keep_elem_refs(pObject, x, y) 13480 retval = _fl_get_input_cursorpos(pObject, px, py) 13481 return retval, x, y
13482 13483
13484 -def fl_set_input_cursor_visible(pObject, visible):
13485 """ fl_set_input_cursor_visible(pObject, visible) 13486 """ 13487 13488 _fl_set_input_cursor_visible = cfuncproto( 13489 load_so_libforms(), "fl_set_input_cursor_visible", 13490 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13491 """void fl_set_input_cursor_visible(FL_OBJECT * ob, int visible) 13492 """) 13493 ivisible = convert_to_int(visible) 13494 keep_elem_refs(pObject, visible, ivisible) 13495 _fl_set_input_cursor_visible(pObject, ivisible)
13496 13497
13498 -def fl_get_input_numberoflines(pObject):
13499 """ fl_get_input_numberoflines(pObject) -> lines num. 13500 """ 13501 13502 _fl_get_input_numberoflines = cfuncproto( 13503 load_so_libforms(), "fl_get_input_numberoflines", 13504 cty.c_int, [cty.POINTER(FL_OBJECT)], 13505 """int fl_get_input_numberoflines(FL_OBJECT * ob) 13506 """) 13507 keep_elem_refs(pObject) 13508 retval = _fl_get_input_numberoflines(pObject) 13509 return retval
13510 13511 13512 #def fl_get_input_format(pObject, fmt, sep) *API change*
13513 -def fl_get_input_format(pObject):
13514 """ fl_get_input_format(pObject) -> fmt, sep 13515 """ 13516 13517 _fl_get_input_format = cfuncproto( 13518 load_so_libforms(), "fl_get_input_format", 13519 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 13520 cty.POINTER(cty.c_int)], 13521 """void fl_get_input_format(FL_OBJECT * ob, int * fmt, int * sep) 13522 """) 13523 fmt, pfmt = make_int_and_pointer() 13524 sep, psep = make_int_and_pointer() 13525 keep_elem_refs(pObject, fmt, sep, pfmt, psep) 13526 _fl_get_input_format(pObject, pfmt, psep) 13527 return fmt, sep
13528 13529
13530 -def fl_get_input(pObject):
13531 """ fl_get_input(pObject) -> input string 13532 """ 13533 13534 _fl_get_input = cfuncproto( 13535 load_so_libforms(), "fl_get_input", 13536 STRING, [cty.POINTER(FL_OBJECT)], 13537 """const char * fl_get_input(FL_OBJECT * ob) 13538 """) 13539 keep_elem_refs(pObject) 13540 retval = _fl_get_input(pObject) 13541 return retval
13542 13543 13544 FL_INPUTVALIDATOR = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), STRING, 13545 STRING, cty.c_int) 13546
13547 -def fl_set_input_filter(pObject, py_InputValidator):
13548 """ 13549 fl_set_input_filter(pObject, py_InputValidator) -> input_filter func. 13550 """ 13551 13552 _fl_set_input_filter = cfuncproto( 13553 load_so_libforms(), "fl_set_input_filter", 13554 FL_INPUTVALIDATOR, [cty.POINTER(FL_OBJECT), FL_INPUTVALIDATOR], 13555 """FL_INPUTVALIDATOR fl_set_input_filter(FL_OBJECT * ob, 13556 FL_INPUTVALIDATOR validate) 13557 """) 13558 c_InputValidator = FL_INPUTVALIDATOR(py_InputValidator) 13559 keep_cfunc_refs(c_InputValidator, py_InputValidator) 13560 keep_elem_refs(pObject) 13561 retval = _fl_set_input_filter(pObject, c_InputValidator) 13562 return retval
13563 13564
13565 -def fl_validate_input(pObject):
13566 """ fl_validate_input(pObject) -> num. 13567 """ 13568 13569 _fl_validate_input = cfuncproto( 13570 load_so_libforms(), "fl_validate_input", 13571 cty.c_int, [cty.POINTER(FL_OBJECT)], 13572 """int fl_validate_input(FL_OBJECT * obj) 13573 """) 13574 keep_elem_refs(pObject) 13575 retval = _fl_validate_input(pObject) 13576 return retval
13577 13578 13579 fl_set_input_shortcut = fl_set_object_shortcut 13580 13581 13582 # edit keys 13583
13584 -def fl_set_input_editkeymap(pEditKeymap):
13585 """ fl_set_input_editkeymap(pEditKeymap) 13586 """ 13587 13588 _fl_set_input_editkeymap = cfuncproto( 13589 load_so_libforms(), "fl_set_input_editkeymap", 13590 None, [cty.POINTER(FL_EditKeymap)], 13591 """void fl_set_input_editkeymap(const char * keymap) 13592 """) 13593 keep_elem_refs(pEditKeymap) 13594 _fl_set_input_editkeymap(pEditKeymap)
13595 13596 13597 13598 ##################### 13599 # forms.h (menu.h) 13600 # Object Class: Menu 13601 ##################### 13602 13603 # Routines 13604
13605 -def fl_create_menu(menutype, x, y, w, h, label):
13606 """ fl_create_menu(menutype, x, y, w, h, label) -> pObject 13607 """ 13608 13609 _fl_create_menu = cfuncproto( 13610 load_so_libforms(), "fl_create_menu", 13611 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 13612 FL_Coord, STRING], 13613 """FL_OBJECT * fl_create_menu(int type, FL_Coord x, FL_Coord y, 13614 FL_Coord w, FL_Coord h, const char * label) 13615 """) 13616 check_admitted_listvalues(menutype, MENUTYPE_list) 13617 imenutype = convert_to_int(menutype) 13618 ix = convert_to_FL_Coord(x) 13619 iy = convert_to_FL_Coord(y) 13620 iw = convert_to_FL_Coord(w) 13621 ih = convert_to_FL_Coord(h) 13622 slabel = convert_to_string(label) 13623 keep_elem_refs(menutype, x, y, w, h, label, imenutype, ix, iy, 13624 iw, ih, slabel) 13625 retval = _fl_create_menu(imenutype, ix, iy, iw, ih, slabel) 13626 return retval
13627 13628
13629 -def fl_add_menu(menutype, x, y, w, h, label):
13630 """ fl_add_menu(menutype, x, y, w, h, label) -> pObject 13631 """ 13632 13633 _fl_add_menu = cfuncproto( 13634 load_so_libforms(), "fl_add_menu", 13635 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 13636 FL_Coord, STRING], 13637 """FL_OBJECT * fl_add_menu(int type, FL_Coord x, FL_Coord y, 13638 FL_Coord w, FL_Coord h, const char * label) DEPRECATED 13639 """) 13640 check_admitted_listvalues(menutype, MENUTYPE_list) 13641 imenutype = convert_to_int(menutype) 13642 ix = convert_to_FL_Coord(x) 13643 iy = convert_to_FL_Coord(y) 13644 iw = convert_to_FL_Coord(w) 13645 ih = convert_to_FL_Coord(h) 13646 slabel = convert_to_string(label) 13647 keep_elem_refs(menutype, x, y, w, h, label, imenutype, ix, iy, 13648 iw, ih, slabel) 13649 retval = _fl_add_menu(imenutype, ix, iy, iw, ih, slabel) 13650 return retval
13651 13652
13653 -def fl_clear_menu(pObject):
13654 """ fl_clear_menu(pObject) 13655 """ 13656 13657 _fl_clear_menu = cfuncproto( 13658 load_so_libforms(), "fl_clear_menu", 13659 None, [cty.POINTER(FL_OBJECT)], 13660 """void fl_clear_menu(FL_OBJECT * ob) DEPRECATED 13661 """) 13662 keep_elem_refs(pObject) 13663 _fl_clear_menu(pObject)
13664 13665
13666 -def fl_set_menu(pObject, menustr):
13667 """ 13668 fl_set_menu(pObject, menustr) 13669 13670 Sets the menu to a particular menu string. 13671 13672 @param pObject : pointer to menu object 13673 @param menustr : text string of menu 13674 """ 13675 13676 _fl_set_menu = cfuncproto( 13677 load_so_libforms(), "fl_set_menu", 13678 None, [cty.POINTER(FL_OBJECT), STRING], 13679 """void fl_set_menu(FL_OBJECT * ob, const char * menustr) DEPRECATED 13680 """) 13681 smenustr = convert_to_string(menustr) 13682 keep_elem_refs(pObject, menustr, smenustr) 13683 _fl_set_menu(pObject, smenustr)
13684 13685
13686 -def fl_addto_menu(pObject, menustr):
13687 """ fl_addto_menu(pObject, menustr) -> num. 13688 """ 13689 13690 _fl_addto_menu = cfuncproto( 13691 load_so_libforms(), "fl_addto_menu", 13692 cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 13693 """int fl_addto_menu(FL_OBJECT * ob, const char * menustr) DEPRECATED 13694 """) 13695 smenustr = convert_to_string(menustr) 13696 keep_elem_refs(pObject, menustr, smenustr) 13697 retval = _fl_addto_menu(pObject, smenustr) 13698 return retval
13699 13700
13701 -def fl_replace_menu_item(pObject, numb, itemstr):
13702 """ fl_replace_menu_item(pObject, numb, itemstr) 13703 """ 13704 13705 _fl_replace_menu_item = cfuncproto( 13706 load_so_libforms(), "fl_replace_menu_item", 13707 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 13708 """void fl_replace_menu_item(FL_OBJECT * ob, int numb, 13709 const char * str) DEPRECATED 13710 """) 13711 inumb = convert_to_int(numb) 13712 sitemstr = convert_to_string(itemstr) 13713 keep_elem_refs(pObject, numb, itemstr, inumb, sitemstr) 13714 _fl_replace_menu_item(pObject, inumb, sitemstr)
13715 13716
13717 -def fl_delete_menu_item(pObject, numb):
13718 """ fl_delete_menu_item(pObject, numb) 13719 """ 13720 13721 _fl_delete_menu_item = cfuncproto( 13722 load_so_libforms(), "fl_delete_menu_item", 13723 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13724 """void fl_delete_menu_item(FL_OBJECT * ob, int numb) DEPRECATED 13725 """) 13726 inumb = convert_to_int(numb) 13727 keep_elem_refs(pObject, numb, inumb) 13728 _fl_delete_menu_item(pObject, inumb)
13729 13730 13731 #already defined in xfdata 13732 FL_PUP_CB = cty.CFUNCTYPE(cty.c_int, cty.c_int) 13733
13734 -def fl_set_menu_item_callback(pObject, numb, py_PupCb):
13735 """ fl_set_menu_item_callback(pObject, numb, py_PupCb) -> callback 13736 """ 13737 13738 _fl_set_menu_item_callback = cfuncproto( 13739 load_so_libforms(), "fl_set_menu_item_callback", 13740 FL_PUP_CB, [cty.POINTER(FL_OBJECT), cty.c_int, FL_PUP_CB], 13741 """FL_PUP_CB fl_set_menu_item_callback(FL_OBJECT * ob, int numb, 13742 FL_PUP_CB cb) 13743 """) 13744 inumb = convert_to_int(numb) 13745 c_PupCb = FL_PUP_CB(py_PupCb) 13746 keep_cfunc_refs(c_PupCb, py_PupCb) 13747 keep_elem_refs(pObject, numb, inumb) 13748 retval = _fl_set_menu_item_callback(pObject, inumb, c_PupCb) 13749 return retval
13750 13751
13752 -def fl_set_menu_item_shortcut(pObject, itemnum, textsc):
13753 """ 13754 fl_set_menu_item_shortcut(pObject, itemnum, textsc) 13755 13756 Sets the shortcut of a menu item. 13757 13758 @param pObject : pointer to menu object 13759 @param itemnum : item number to be operated on 13760 @param textsc : text of shortcut to be set 13761 """ 13762 13763 _fl_set_menu_item_shortcut = cfuncproto( 13764 load_so_libforms(), "fl_set_menu_item_shortcut", 13765 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 13766 """void fl_set_menu_item_shortcut(FL_OBJECT * ob, int numb, 13767 const char * str) DEPRECATED 13768 """) 13769 iitemnum = convert_to_int(itemnum) 13770 stextsc = convert_to_string(textsc) 13771 keep_elem_refs(pObject, itemnum, stextsc, iitemnum, stextsc) 13772 _fl_set_menu_item_shortcut(pObject, iitemnum, stextsc)
13773 13774
13775 -def fl_set_menu_item_mode(pObject, itemnum, mode):
13776 """ 13777 fl_set_menu_item_mode(pObject, itemnum, mode) 13778 13779 Sets the mode of a menu item. 13780 13781 @param pObject : pointer to menu object 13782 @param itemnum : id of an item to be operated on 13783 @param mode : mode to be set 13784 """ 13785 13786 _fl_set_menu_item_mode = cfuncproto( 13787 load_so_libforms(), "fl_set_menu_item_mode", 13788 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_uint], 13789 """void fl_set_menu_item_mode(FL_OBJECT * ob, int numb, 13790 unsigned int mode) DEPRECATED 13791 """) 13792 iitemnum = convert_to_int(itemnum) 13793 uimode = convert_to_uint(mode) 13794 keep_elem_refs(pObject, itemnum, mode, iitemnum, uimode) 13795 _fl_set_menu_item_mode(pObject, iitemnum, uimode)
13796 13797
13798 -def fl_show_menu_symbol(pObject, showflag):
13799 """ 13800 fl_show_menu_symbol(pObject, showflag) 13801 13802 Makes the menu symbol visible or not. 13803 13804 @param pObject : pointer to menu object 13805 @param showflag : flag to show menu or not (1|0) 13806 """ 13807 13808 _fl_show_menu_symbol = cfuncproto( 13809 load_so_libforms(), "fl_show_menu_symbol", 13810 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13811 """void fl_show_menu_symbol(FL_OBJECT * ob, int show) DEPRECATED 13812 """) 13813 ishowflag = convert_to_int(showflag) 13814 keep_elem_refs(pObject, showflag, ishowflag) 13815 _fl_show_menu_symbol(pObject, ishowflag)
13816 13817
13818 -def fl_set_menu_popup(pObject, pup):
13819 """ fl_set_menu_popup(pObject, pup) 13820 """ 13821 13822 _fl_set_menu_popup = cfuncproto( 13823 load_so_libforms(), "fl_set_menu_popup", 13824 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13825 """void fl_set_menu_popup(FL_OBJECT * ob, int pup) DEPRECATED 13826 """) 13827 ipup = convert_to_int(pup) 13828 keep_elem_refs(pObject, pup, ipup) 13829 _fl_set_menu_popup(pObject, ipup)
13830 13831
13832 -def fl_get_menu_popup(pObject):
13833 """ fl_get_menu_popup(pObject) -> num. 13834 """ 13835 13836 _fl_get_menu_popup = cfuncproto( 13837 load_so_libforms(), "fl_get_menu_popup", 13838 cty.c_int, [cty.POINTER(FL_OBJECT)], 13839 """int fl_get_menu_popup(FL_OBJECT * ob) DEPRECATED 13840 """) 13841 keep_elem_refs(pObject) 13842 retval = _fl_get_menu_popup(pObject) 13843 return retval
13844 13845
13846 -def fl_get_menu(pObject):
13847 """ fl_get_menu(pObject) -> num. 13848 """ 13849 13850 _fl_get_menu = cfuncproto( 13851 load_so_libforms(), "fl_get_menu", 13852 cty.c_int, [cty.POINTER(FL_OBJECT)], 13853 """int fl_get_menu(FL_OBJECT * ob) DEPRECATED 13854 """) 13855 keep_elem_refs(pObject) 13856 retval = _fl_get_menu(pObject) 13857 return retval
13858 13859
13860 -def fl_get_menu_item_text(pObject, numb):
13861 """ fl_get_menu_item_text(pObject, numb) -> text string 13862 """ 13863 13864 _fl_get_menu_item_text = cfuncproto( 13865 load_so_libforms(), "fl_get_menu_item_text", 13866 STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 13867 """const char * fl_get_menu_item_text(FL_OBJECT * ob, int numb) DEPRECATED 13868 """) 13869 inumb = convert_to_int(numb) 13870 keep_elem_refs(pObject, numb, inumb) 13871 retval = _fl_get_menu_item_text(pObject, inumb) 13872 return retval
13873 13874
13875 -def fl_get_menu_maxitems(pObject):
13876 """ fl_get_menu_maxitems(pObject) -> items num. 13877 """ 13878 13879 _fl_get_menu_maxitems = cfuncproto( 13880 load_so_libforms(), "fl_get_menu_maxitems", 13881 cty.c_int, [cty.POINTER(FL_OBJECT)], 13882 """int fl_get_menu_maxitems(FL_OBJECT * ob) DEPRECATED 13883 """) 13884 keep_elem_refs(pObject) 13885 retval = _fl_get_menu_maxitems(pObject) 13886 return retval
13887 13888
13889 -def fl_get_menu_item_mode(pObject, numb):
13890 """ fl_get_menu_item_mode(pObject, numb) -> mode num. 13891 """ 13892 13893 _fl_get_menu_item_mode = cfuncproto( 13894 load_so_libforms(), "fl_get_menu_item_mode", 13895 cty.c_uint, [cty.POINTER(FL_OBJECT), cty.c_int], 13896 """unsigned int fl_get_menu_item_mode(FL_OBJECT * ob, int numb) DEPRECATED 13897 """) 13898 inumb = convert_to_int(numb) 13899 keep_elem_refs(pObject, numb, inumb) 13900 retval = _fl_get_menu_item_mode(pObject, inumb) 13901 return retval
13902 13903
13904 -def fl_get_menu_text(pObject):
13905 """ fl_get_menu_text(pObject) -> text string 13906 """ 13907 13908 _fl_get_menu_text = cfuncproto( 13909 load_so_libforms(), "fl_get_menu_text", 13910 STRING, [cty.POINTER(FL_OBJECT)], 13911 """const char * fl_get_menu_text(FL_OBJECT * ob) DEPRECATED 13912 """) 13913 keep_elem_refs(pObject) 13914 retval = _fl_get_menu_text(pObject) 13915 return retval
13916 13917
13918 -def fl_set_menu_entries(pObject, pPopupEntry):
13919 """ fl_set_menu_entries(pObject, pPopupEntry) -> num. 13920 """ 13921 13922 _fl_set_menu_entries = cfuncproto( 13923 load_so_libforms(), "fl_set_menu_entries", 13924 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_PUP_ENTRY)], 13925 """int fl_set_menu_entries(FL_OBJECT * ob, FL_PUP_ENTRY * ent) DEPRECATED 13926 """) 13927 keep_elem_refs(pObject, pPopupEntry) 13928 retval = _fl_set_menu_entries(pObject, pPopupEntry) 13929 return retval
13930 13931
13932 -def fl_set_menu_notitle(pObject, off):
13933 """ fl_set_menu_notitle(pObject, off) -> num. 13934 """ 13935 13936 _fl_set_menu_notitle = cfuncproto( 13937 load_so_libforms(), "fl_set_menu_notitle", 13938 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 13939 """int fl_set_menu_notitle(FL_OBJECT * ob, int off) DEPRECATED? 13940 """) 13941 ioff = convert_to_int(off) 13942 keep_elem_refs(pObject, off, ioff) 13943 retval = _fl_set_menu_notitle(pObject, ioff) 13944 return retval
13945 13946
13947 -def fl_set_menu_item_id(pObject, item, idnum):
13948 """ fl_set_menu_item_id(pObject, item, idnum) -> num. 13949 """ 13950 13951 _fl_set_menu_item_id = cfuncproto( 13952 load_so_libforms(), "fl_set_menu_item_id", 13953 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 13954 """int fl_set_menu_item_id(FL_OBJECT * ob, int item, int id) 13955 """) 13956 iitem = convert_to_int(item) 13957 iidnum = convert_to_int(idnum) 13958 keep_elem_refs(pObject, item, idnum, iitem, iidnum) 13959 retval = _fl_set_menu_item_id(pObject, iitem, iidnum) 13960 return retval
13961 13962 13963 13964 # Nmenu object types 13965
13966 -def fl_create_nmenu(nmenutype, x, y, w, h, label):
13967 """ 13968 fl_create_nmenu(nmenutype, x, y, w, h, label) -> pObject 13969 13970 Creates a nmenu object. 13971 13972 @param nmenutype : type of nmenu 13973 @param x : horizontal position of nmenu (upper-left corner) 13974 @param y : vertical position of nmenu (upper-left corner) 13975 @param w : width of nmenu object in pixel 13976 @param h : height of nmenu object in pixel 13977 @param label : text label of nmenu object 13978 """ 13979 13980 _fl_create_nmenu = cfuncproto( 13981 load_so_libforms(), "fl_create_nmenu", 13982 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 13983 FL_Coord, STRING], 13984 """FL_OBJECT * fl_create_nmenu(int p1, FL_Coord p2, FL_Coord p3, 13985 FL_Coord p4, FL_Coord p5, const char * p6) 13986 """) 13987 check_admitted_listvalues(nmenutype, NMENUTYPE_list) 13988 inmenutype = convert_to_int(nmenutype) 13989 ix = convert_to_FL_Coord(x) 13990 iy = convert_to_FL_Coord(y) 13991 iw = convert_to_FL_Coord(w) 13992 ih = convert_to_FL_Coord(h) 13993 slabel = convert_to_string(label) 13994 keep_elem_refs(nmenutype, x, y, w, h, label, inmenutype, ix, iy, 13995 iw, ih, slabel) 13996 retval = _fl_create_nmenu(inmenutype, ix, iy, iw, ih, slabel) 13997 return retval
13998 13999
14000 -def fl_add_nmenu(nmenutype, x, y, w, h, label):
14001 """ 14002 fl_add_nmenu(nmenutype, x, y, w, h, label) -> pObject 14003 14004 Adds a nmenu object. 14005 14006 @param nmenutype : type of nmenu object 14007 @param x : horizontal position of nmenu (upper-left corner) 14008 @param y : vertical position of nmenu (upper-left corner) 14009 @param w : width of nmenu object in pixel 14010 @param h : height of nmenu object in pixel 14011 @param label : text label of nmenu object 14012 """ 14013 14014 _fl_add_nmenu = cfuncproto( 14015 load_so_libforms(), "fl_add_nmenu", 14016 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14017 FL_Coord, STRING], 14018 """FL_OBJECT * fl_add_nmenu(int p1, FL_Coord p2, FL_Coord p3, 14019 FL_Coord p4, FL_Coord p5, const char * p6) 14020 """) 14021 check_admitted_listvalues(nmenutype, NMENUTYPE_list) 14022 inmenutype = convert_to_int(nmenutype) 14023 ix = convert_to_FL_Coord(x) 14024 iy = convert_to_FL_Coord(y) 14025 iw = convert_to_FL_Coord(w) 14026 ih = convert_to_FL_Coord(h) 14027 slabel = convert_to_string(label) 14028 keep_elem_refs(nmenutype, x, y, w, h, label, inmenutype, ix, iy, 14029 iw, ih, slabel) 14030 retval = _fl_add_nmenu(inmenutype, ix, iy, iw, ih, slabel) 14031 return retval
14032 14033
14034 -def fl_clear_nmenu(pObject):
14035 """ fl_clear_nmenu(pObject) -> num. 14036 """ 14037 14038 _fl_clear_nmenu = cfuncproto( 14039 load_so_libforms(), "fl_clear_nmenu", 14040 cty.c_int, [cty.POINTER(FL_OBJECT)], 14041 """int fl_clear_nmenu(FL_OBJECT * p1) 14042 """) 14043 keep_elem_refs(pObject) 14044 retval = _fl_clear_nmenu(pObject) 14045 return retval
14046 14047
14048 -def fl_add_nmenu_items(pObject, itemstr):
14049 """ fl_add_nmenu_items(pObject, itemstr) -> pPopupEntry 14050 """ 14051 14052 _fl_add_nmenu_items = cfuncproto( 14053 load_so_libforms(), "fl_add_nmenu_items", 14054 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14055 """FL_POPUP_ENTRY * fl_add_nmenu_items(FL_OBJECT * p1, 14056 const char * p2) 14057 """) 14058 sitemstr = convert_to_string(itemstr) 14059 keep_elem_refs(pObject, itemstr, sitemstr) 14060 retval = _fl_add_nmenu_items(pObject, sitemstr) 14061 return retval
14062 14063
14064 -def fl_insert_nmenu_items(pObject, pPopupEntry, itemstr):
14065 """ fl_insert_nmenu_items(pObject, pPopupEntry, itemstr) -> pPopupEntry 14066 """ 14067 14068 _fl_insert_nmenu_items = cfuncproto( 14069 load_so_libforms(), "fl_insert_nmenu_items", 14070 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 14071 cty.POINTER(FL_POPUP_ENTRY), STRING], 14072 """FL_POPUP_ENTRY * fl_insert_nmenu_items(FL_OBJECT * p1, 14073 FL_POPUP_ENTRY * p2, const char * p3) 14074 """) 14075 sitemstr = convert_to_string(itemstr) 14076 keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 14077 retval = _fl_insert_nmenu_items(pObject, pPopupEntry, sitemstr) 14078 return retval
14079 14080
14081 -def fl_replace_nmenu_item(pObject, pPopupEntry, itemstr):
14082 """ fl_replace_nmenu_item(pObject, pPopupEntry, itemstr) -> pPopupEntry 14083 """ 14084 14085 _fl_replace_nmenu_item = cfuncproto( 14086 load_so_libforms(), "fl_replace_nmenu_item", 14087 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 14088 cty.POINTER(FL_POPUP_ENTRY), STRING], 14089 """FL_POPUP_ENTRY * fl_replace_nmenu_item(FL_OBJECT * p1, 14090 FL_POPUP_ENTRY * p2, const char * p3) 14091 """) 14092 sitemstr = convert_to_string(itemstr) 14093 keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 14094 retval = _fl_replace_nmenu_item(pObject, pPopupEntry, sitemstr) 14095 return retval
14096 14097
14098 -def fl_delete_nmenu_item(pObject, pPopupEntry):
14099 """ fl_delete_nmenu_item(pObject, pPopupEntry) -> num. 14100 """ 14101 14102 _fl_delete_nmenu_item = cfuncproto( 14103 load_so_libforms(), "fl_delete_nmenu_item", 14104 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ENTRY)], 14105 """int fl_delete_nmenu_item(FL_OBJECT * p1, FL_POPUP_ENTRY * p2) 14106 """) 14107 keep_elem_refs(pObject, pPopupEntry) 14108 retval = _fl_delete_nmenu_item(pObject, pPopupEntry) 14109 return retval
14110 14111
14112 -def fl_set_nmenu_items(pObject, pPopupItem):
14113 """ fl_set_nmenu_items(pObject, pPopupItem) -> pPopupEntry 14114 """ 14115 14116 _fl_set_nmenu_items = cfuncproto( 14117 load_so_libforms(), "fl_set_nmenu_items", 14118 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 14119 cty.POINTER(FL_POPUP_ITEM)], 14120 """FL_POPUP_ENTRY * fl_set_nmenu_items(FL_OBJECT * p1, 14121 FL_POPUP_ITEM * p2) 14122 """) 14123 keep_elem_refs(pObject, pPopupItem) 14124 retval = _fl_set_nmenu_items(pObject, pPopupItem) 14125 return retval
14126 14127
14128 -def fl_get_nmenu_popup(pObject):
14129 """ fl_get_nmenu_popup(pObject) -> pPopup 14130 """ 14131 14132 _fl_get_nmenu_popup = cfuncproto( 14133 load_so_libforms(), "fl_get_nmenu_popup", 14134 cty.POINTER(FL_POPUP), [cty.POINTER(FL_OBJECT)], 14135 """FL_POPUP * fl_get_nmenu_popup(FL_OBJECT * p1) 14136 """) 14137 keep_elem_refs(pObject) 14138 retval = _fl_get_nmenu_popup(pObject) 14139 return retval
14140 14141
14142 -def fl_set_nmenu_popup(pObject, pPopup):
14143 """ fl_set_nmenu_popup(pObject, pPopup) -> num. 14144 """ 14145 14146 _fl_set_nmenu_popup = cfuncproto( 14147 load_so_libforms(), "fl_set_nmenu_popup", 14148 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP)], 14149 """int fl_set_nmenu_popup(FL_OBJECT * p1, FL_POPUP * p2) 14150 """) 14151 keep_elem_refs(pObject, pPopup) 14152 retval = _fl_set_nmenu_popup(pObject, pPopup) 14153 return retval
14154 14155
14156 -def fl_get_nmenu_item(pObject):
14157 """ fl_get_nmenu_item(pObject) -> pPopupReturn 14158 """ 14159 14160 _fl_get_nmenu_item = cfuncproto( 14161 load_so_libforms(), "fl_get_nmenu_item", 14162 cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT)], 14163 """FL_POPUP_RETURN * fl_get_nmenu_item(FL_OBJECT * p1) 14164 """) 14165 keep_elem_refs(pObject) 14166 retval = _fl_get_nmenu_item(pObject) 14167 return retval
14168 14169
14170 -def fl_get_nmenu_item_by_value(pObject, value):
14171 """ fl_get_nmenu_item_by_value(pObject, value) -> pPopupEntry 14172 """ 14173 14174 _fl_get_nmenu_item_by_value = cfuncproto( 14175 load_so_libforms(), "fl_get_nmenu_item_by_value", 14176 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), cty.c_long], 14177 """FL_POPUP_ENTRY * fl_get_nmenu_item_by_value(FL_OBJECT * p1, 14178 long int p2) 14179 """) 14180 lvalue = convert_to_long(value) 14181 keep_elem_refs(pObject, value, lvalue) 14182 retval = _fl_get_nmenu_item_by_value(pObject, lvalue) 14183 return retval
14184 14185
14186 -def fl_get_nmenu_item_by_label(pObject, label):
14187 """ fl_get_nmenu_item_by_label(pObject, label) -> pPopupEntry 14188 """ 14189 14190 _fl_get_nmenu_item_by_label = cfuncproto( 14191 load_so_libforms(), "fl_get_nmenu_item_by_label", 14192 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14193 """FL_POPUP_ENTRY * fl_get_nmenu_item_by_label(FL_OBJECT * p1, 14194 const char * p2) 14195 """) 14196 slabel = convert_to_string(label) 14197 keep_elem_refs(pObject, label, slabel) 14198 retval = _fl_get_nmenu_item_by_label(pObject, slabel) 14199 return retval
14200 14201
14202 -def fl_get_nmenu_item_by_text(pObject, text):
14203 """ fl_get_nmenu_item_by_text(pObject, text) -> pPopupEntry 14204 """ 14205 14206 _fl_get_nmenu_item_by_text = cfuncproto( 14207 load_so_libforms(), "fl_get_nmenu_item_by_text", 14208 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14209 """FL_POPUP_ENTRY * fl_get_nmenu_item_by_text(FL_OBJECT * p1, 14210 const char * p2) 14211 """) 14212 stext = convert_to_string(text) 14213 keep_elem_refs(pObject, text, stext) 14214 retval = _fl_get_nmenu_item_by_text(pObject, stext) 14215 return retval
14216 14217
14218 -def fl_set_nmenu_policy(pObject, num):
14219 """ fl_set_nmenu_policy(pObject, num) -> num. 14220 """ 14221 14222 _fl_set_nmenu_policy = cfuncproto( 14223 load_so_libforms(), "fl_set_nmenu_policy", 14224 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 14225 """int fl_set_nmenu_policy(FL_OBJECT * p1, int p2) 14226 """) 14227 inum = convert_to_int(num) 14228 keep_elem_refs(pObject, num, inum) 14229 retval = _fl_set_nmenu_policy(pObject, inum) 14230 return retval
14231 14232
14233 -def fl_set_nmenu_hl_text_color(pObject, colr):
14234 """ fl_set_nmenu_hl_text_color(pObject, colr) -> color 14235 """ 14236 14237 _fl_set_nmenu_hl_text_color = cfuncproto( 14238 load_so_libforms(), "fl_set_nmenu_hl_text_color", 14239 FL_COLOR, [cty.POINTER(FL_OBJECT), FL_COLOR], 14240 """FL_COLOR fl_set_nmenu_hl_text_color(FL_OBJECT * p1, 14241 FL_COLOR p2) 14242 """) 14243 ulcolr = convert_to_FL_COLOR(colr) 14244 keep_elem_refs(pObject, colr, ulcolr) 14245 retval = _fl_set_nmenu_hl_text_color(pObject, ulcolr) 14246 return retval
14247 14248 14249 14250 ######################### 14251 # forms.h (positioner.h) 14252 ######################### 14253 14254 # Routines 14255
14256 -def fl_create_positioner(postype, x, y, w, h, label):
14257 """ fl_create_positioner(postype, x, y, w, h, label) -> pObject 14258 """ 14259 14260 _fl_create_positioner = cfuncproto( 14261 load_so_libforms(), "fl_create_positioner", 14262 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14263 FL_Coord, STRING], 14264 """FL_OBJECT * fl_create_positioner(int type, FL_Coord x, 14265 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 14266 """) 14267 check_admitted_listvalues(postype, POSITIONERTYPE_list) 14268 ipostype = convert_to_int(postype) 14269 ix = convert_to_FL_Coord(x) 14270 iy = convert_to_FL_Coord(y) 14271 iw = convert_to_FL_Coord(w) 14272 ih = convert_to_FL_Coord(h) 14273 slabel = convert_to_string(label) 14274 keep_elem_refs(postype, x, y, w, h, label, ipostype, ix, iy, 14275 iw, ih, slabel) 14276 retval = _fl_create_positioner(ipostype, ix, iy, iw, ih, slabel) 14277 return retval
14278 14279
14280 -def fl_add_positioner(postype, x, y, w, h, label):
14281 """ fl_add_positioner(postype, x, y, w, h, label) -> pObject 14282 """ 14283 14284 _fl_add_positioner = cfuncproto( 14285 load_so_libforms(), "fl_add_positioner", 14286 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14287 FL_Coord, STRING], 14288 """FL_OBJECT * fl_add_positioner(int type, FL_Coord x, FL_Coord y, 14289 FL_Coord w, FL_Coord h, const char * label) 14290 """) 14291 check_admitted_listvalues(postype, POSITIONERTYPE_list) 14292 ipostype = convert_to_int(postype) 14293 ix = convert_to_FL_Coord(x) 14294 iy = convert_to_FL_Coord(y) 14295 iw = convert_to_FL_Coord(w) 14296 ih = convert_to_FL_Coord(h) 14297 slabel = convert_to_string(label) 14298 keep_elem_refs(postype, x, y, w, h, label, ipostype, ix, iy, 14299 iw, ih, slabel) 14300 retval = _fl_add_positioner(ipostype, ix, iy, iw, ih, slabel) 14301 return retval
14302 14303
14304 -def fl_set_positioner_xvalue(pObject, val):
14305 """ fl_set_positioner_xvalue(pObject, val) 14306 """ 14307 14308 _fl_set_positioner_xvalue = cfuncproto( 14309 load_so_libforms(), "fl_set_positioner_xvalue", 14310 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14311 """void fl_set_positioner_xvalue(FL_OBJECT * ob, double val) 14312 """) 14313 fval = convert_to_double(val) 14314 keep_elem_refs(pObject, val, fval) 14315 _fl_set_positioner_xvalue(pObject, fval)
14316 14317
14318 -def fl_get_positioner_xvalue(pObject):
14319 """ fl_get_positioner_xvalue(pObject) -> floatnum 14320 """ 14321 14322 _fl_get_positioner_xvalue = cfuncproto( 14323 load_so_libforms(), "fl_get_positioner_xvalue", 14324 cty.c_double, [cty.POINTER(FL_OBJECT)], 14325 """double fl_get_positioner_xvalue(FL_OBJECT * ob) 14326 """) 14327 keep_elem_refs(pObject) 14328 retval = _fl_get_positioner_xvalue(pObject) 14329 return retval
14330 14331
14332 -def fl_set_positioner_xbounds(pObject, minbound, maxbound):
14333 """ fl_set_positioner_xbounds(pObject, minbound, maxbound) 14334 """ 14335 14336 _fl_set_positioner_xbounds = cfuncproto( 14337 load_so_libforms(), "fl_set_positioner_xbounds", 14338 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 14339 """void fl_set_positioner_xbounds(FL_OBJECT * ob, double min, 14340 double max) 14341 """) 14342 fminbound = convert_to_double(minbound) 14343 fmaxbound = convert_to_double(maxbound) 14344 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 14345 _fl_set_positioner_xbounds(pObject, fminbound, fmaxbound)
14346 14347 14348 #def fl_get_positioner_xbounds(pObject, minbound, maxbound) *API change*
14349 -def fl_get_positioner_xbounds(pObject):
14350 """ fl_get_positioner_xbounds(pObject) -> minbound, maxbound 14351 """ 14352 14353 _fl_get_positioner_xbounds = cfuncproto( 14354 load_so_libforms(), "fl_get_positioner_xbounds", 14355 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 14356 cty.POINTER(cty.c_double)], 14357 """void fl_get_positioner_xbounds(FL_OBJECT * ob, double * min, 14358 double * max) 14359 """) 14360 minbound, pminbound = make_double_and_pointer() 14361 maxbound, pmaxbound = make_double_and_pointer() 14362 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 14363 _fl_get_positioner_xbounds(pObject, pminbound, pmaxbound) 14364 return minbound, maxbound
14365 14366
14367 -def fl_set_positioner_yvalue(pObject, val):
14368 """ fl_set_positioner_yvalue(pObject, val) 14369 """ 14370 14371 _fl_set_positioner_yvalue = cfuncproto( 14372 load_so_libforms(), "fl_set_positioner_yvalue", 14373 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14374 """void fl_set_positioner_yvalue(FL_OBJECT * ob, double val) 14375 """) 14376 fval = convert_to_double(val) 14377 keep_elem_refs(pObject, val, fval) 14378 _fl_set_positioner_yvalue(pObject, fval)
14379 14380
14381 -def fl_get_positioner_yvalue(pObject):
14382 """ fl_get_positioner_yvalue(pObject) -> floatnum 14383 """ 14384 14385 _fl_get_positioner_yvalue = cfuncproto( 14386 load_so_libforms(), "fl_get_positioner_yvalue", 14387 cty.c_double, [cty.POINTER(FL_OBJECT)], 14388 """double fl_get_positioner_yvalue(FL_OBJECT * ob) 14389 """) 14390 keep_elem_refs(pObject) 14391 retval = _fl_get_positioner_yvalue(pObject) 14392 return retval
14393 14394
14395 -def fl_set_positioner_ybounds(pObject, minbound, maxbound):
14396 """ fl_set_positioner_ybounds(pObject, minbound, maxbound) 14397 """ 14398 14399 _fl_set_positioner_ybounds = cfuncproto( 14400 load_so_libforms(), "fl_set_positioner_ybounds", 14401 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 14402 """void fl_set_positioner_ybounds(FL_OBJECT * ob, double min, 14403 double max) 14404 """) 14405 fminbound = convert_to_double(minbound) 14406 fmaxbound = convert_to_double(maxbound) 14407 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 14408 _fl_set_positioner_ybounds(pObject, fminbound, fmaxbound)
14409 14410 14411 #def fl_get_positioner_ybounds(pObject, minbound, maxbound) *API change*
14412 -def fl_get_positioner_ybounds(pObject):
14413 """ fl_get_positioner_ybounds(pObject) -> minbound, maxbound 14414 """ 14415 14416 _fl_get_positioner_ybounds = cfuncproto( 14417 load_so_libforms(), "fl_get_positioner_ybounds", 14418 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 14419 cty.POINTER(cty.c_double)], 14420 """void fl_get_positioner_ybounds(FL_OBJECT * ob, double * min, 14421 double * max) 14422 """) 14423 minbound, pminbound = make_double_and_pointer() 14424 maxbound, pmaxbound = make_double_and_pointer() 14425 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 14426 _fl_get_positioner_ybounds(pObject, pminbound, pmaxbound) 14427 return minbound, maxbound
14428 14429
14430 -def fl_set_positioner_xstep(pObject, value):
14431 """ fl_set_positioner_xstep(pObject, value) 14432 """ 14433 14434 _fl_set_positioner_xstep = cfuncproto( 14435 load_so_libforms(), "fl_set_positioner_xstep", 14436 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14437 """void fl_set_positioner_xstep(FL_OBJECT * ob, double value) 14438 """) 14439 fvalue = convert_to_double(value) 14440 keep_elem_refs(pObject, value, fvalue) 14441 _fl_set_positioner_xstep(pObject, fvalue)
14442 14443
14444 -def fl_set_positioner_ystep(pObject, value):
14445 """ fl_set_positioner_ystep(pObject, value) 14446 """ 14447 14448 _fl_set_positioner_ystep = cfuncproto( 14449 load_so_libforms(), "fl_set_positioner_ystep", 14450 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14451 """void fl_set_positioner_ystep(FL_OBJECT * ob, double value) 14452 """) 14453 fvalue = convert_to_double(value) 14454 keep_elem_refs(pObject, value, fvalue) 14455 _fl_set_positioner_ystep(pObject, fvalue)
14456 14457
14458 -def fl_set_positioner_return(pObject, value):
14459 """ fl_set_positioner_return(pObject, value) 14460 """ 14461 14462 _fl_set_positioner_return = cfuncproto( 14463 load_so_libforms(), "fl_set_positioner_return", 14464 None, [cty.POINTER(FL_OBJECT), cty.c_int], 14465 """void fl_set_positioner_return(FL_OBJECT * ob, int value) 14466 """) 14467 ivalue = convert_to_int(value) 14468 keep_elem_refs(pObject, value, ivalue) 14469 _fl_set_positioner_return(pObject, ivalue)
14470 14471
14472 -def fl_create_scrollbar(scrolltype, x, y, w, h, label):
14473 """ fl_create_scrollbar(scrolltype, x, y, w, h, label) -> pObject 14474 """ 14475 14476 _fl_create_scrollbar = cfuncproto( 14477 load_so_libforms(), "fl_create_scrollbar", 14478 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14479 FL_Coord, STRING], 14480 """FL_OBJECT * fl_create_scrollbar(int type, FL_Coord x, 14481 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 14482 """) 14483 check_admitted_listvalues(scrolltype, SCROLLTYPE_list) 14484 iscrolltype = convert_to_int(scrolltype) 14485 ix = convert_to_FL_Coord(x) 14486 iy = convert_to_FL_Coord(y) 14487 iw = convert_to_FL_Coord(w) 14488 ih = convert_to_FL_Coord(h) 14489 slabel = convert_to_string(label) 14490 keep_elem_refs(scrolltype, x, y, w, h, label, iscrolltype, ix, iy, 14491 iw, ih, slabel) 14492 retval = _fl_create_scrollbar(iscrolltype, ix, iy, iw, ih, slabel) 14493 return retval
14494 14495
14496 -def fl_add_scrollbar(scrolltype, x, y, w, h, label):
14497 """ 14498 fl_add_scrollbar(scrolltype, x, y, w, h, label) -> pObject 14499 14500 Adds a scrollbar to a form. 14501 14502 @param scrolltype : type of scrollbar 14503 @param x : horizontal position (upper-left corner) 14504 @param y : vertical position (upper-left corner) 14505 @param w : width of the scrollbar 14506 @param h : height of the scrollbar 14507 @param label : label text of the scrollbar 14508 """ 14509 14510 _fl_add_scrollbar = cfuncproto( 14511 load_so_libforms(), "fl_add_scrollbar", 14512 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14513 FL_Coord, STRING], 14514 """FL_OBJECT * fl_add_scrollbar(int type, FL_Coord x, FL_Coord y, 14515 FL_Coord w, FL_Coord h, const char * label) 14516 """) 14517 check_admitted_listvalues(scrolltype, SCROLLTYPE_list) 14518 iscrolltype = convert_to_int(scrolltype) 14519 ix = convert_to_FL_Coord(x) 14520 iy = convert_to_FL_Coord(y) 14521 iw = convert_to_FL_Coord(w) 14522 ih = convert_to_FL_Coord(h) 14523 slabel = convert_to_string(label) 14524 keep_elem_refs(scrolltype, x, y, w, h, label, iscrolltype, ix, iy, 14525 iw, ih, slabel) 14526 retval = _fl_add_scrollbar(iscrolltype, ix, iy, iw, ih, slabel) 14527 return retval
14528 14529
14530 -def fl_get_scrollbar_value(pObject):
14531 """ 14532 fl_get_scrollbar_value(pObject) -> value[float] 14533 14534 Returns the value of a scrollbar. 14535 14536 @param pObject : pointer to object 14537 """ 14538 14539 _fl_get_scrollbar_value = cfuncproto( 14540 load_so_libforms(), "fl_get_scrollbar_value", 14541 cty.c_double, [cty.POINTER(FL_OBJECT)], 14542 """double fl_get_scrollbar_value(FL_OBJECT * ob) 14543 """) 14544 keep_elem_refs(pObject) 14545 retval = _fl_get_scrollbar_value(pObject) 14546 return retval
14547 14548
14549 -def fl_set_scrollbar_value(pObject, val):
14550 """ 14551 fl_set_scrollbar_value(pObject, val) 14552 14553 Sets the value of a scrollbar. 14554 14555 @param pObject : pointer to object 14556 @param val : value of the scrollbar to be set 14557 """ 14558 14559 _fl_set_scrollbar_value = cfuncproto( 14560 load_so_libforms(), "fl_set_scrollbar_value", 14561 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14562 """void fl_set_scrollbar_value(FL_OBJECT * ob, double val) 14563 """) 14564 fval = convert_to_double(val) 14565 keep_elem_refs(pObject, val, fval) 14566 _fl_set_scrollbar_value(pObject, fval)
14567 14568
14569 -def fl_set_scrollbar_size(pObject, val):
14570 """ fl_set_scrollbar_size(pObject, val) 14571 """ 14572 14573 _fl_set_scrollbar_size = cfuncproto( 14574 load_so_libforms(), "fl_set_scrollbar_size", 14575 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14576 """void fl_set_scrollbar_size(FL_OBJECT * ob, double val) 14577 """) 14578 fval = convert_to_double(val) 14579 keep_elem_refs(pObject, val, fval) 14580 _fl_set_scrollbar_size(pObject, fval)
14581 14582
14583 -def fl_set_scrollbar_increment(pObject, leftbtnval, midlbtnval):
14584 """ 14585 fl_set_scrollbar_increment(pObject, leftbtnval, midlbtnval) 14586 14587 Sets the size of the steps of a scrollbar jump. 14588 14589 @param pObject : pointer to object 14590 @param leftbtnval : value to increment if the left mouse button is 14591 pressed 14592 @param midlbtnval : value to increment if the middle mouse button is 14593 pressed 14594 """ 14595 14596 _fl_set_scrollbar_increment = cfuncproto( 14597 load_so_libforms(), "fl_set_scrollbar_increment", 14598 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 14599 """void fl_set_scrollbar_increment(FL_OBJECT * ob, double l, 14600 double r) 14601 """) 14602 fleftbtnval = convert_to_double(leftbtnval) 14603 fmidlbtnval = convert_to_double(midlbtnval) 14604 keep_elem_refs(pObject, leftbtnval, midlbtnval, fleftbtnval, \ 14605 fmidlbtnval) 14606 _fl_set_scrollbar_increment(pObject, fleftbtnval, fmidlbtnval)
14607 14608 14609 #def fl_get_scrollbar_increment(pObject, leftbtnval, valmidlbtnval) *API change*
14610 -def fl_get_scrollbar_increment(pObject):
14611 """ 14612 fl_get_scrollbar_increment(pObject) -> leftbtnval[double], midlbtnval[double] 14613 14614 Returns the increment of size of a scrollbar for left and middle mouse 14615 buttons. 14616 14617 @param pObject : pointer to object 14618 """ 14619 14620 _fl_get_scrollbar_increment = cfuncproto( 14621 load_so_libforms(), "fl_get_scrollbar_increment", 14622 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 14623 cty.POINTER(cty.c_double)], 14624 """void fl_get_scrollbar_increment(FL_OBJECT * ob, double * a, 14625 double * b) 14626 """) 14627 leftbtnval, pleftbtnval = make_double_and_pointer() 14628 midlbtnval, pmidlbtnval = make_double_and_pointer() 14629 keep_elem_refs(pObject, leftbtnval, midlbtnval, pleftbtnval, pmidlbtnval) 14630 _fl_get_scrollbar_increment(pObject, pleftbtnval, pmidlbtnval) 14631 return leftbtnval, midlbtnval
14632 14633
14634 -def fl_set_scrollbar_bounds(pObject, minbound, maxbound):
14635 """ 14636 fl_set_scrollbar_bounds(pObject, minbound, maxbound) 14637 14638 Sets the bounds/limits of a scrollbar. 14639 14640 @param pObject : pointer to object 14641 @param minbound : minimum bound of scrollbar 14642 @param maxbound : maximum bound of scrollbar 14643 """ 14644 14645 _fl_set_scrollbar_bounds = cfuncproto( 14646 load_so_libforms(), "fl_set_scrollbar_bounds", 14647 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 14648 """void fl_set_scrollbar_bounds(FL_OBJECT * ob, double b1, double b2) 14649 """) 14650 fminbound = convert_to_double(minbound) 14651 fmaxbound = convert_to_double(maxbound) 14652 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 14653 _fl_set_scrollbar_bounds(pObject, fminbound, fmaxbound)
14654 14655 14656 #def fl_get_scrollbar_bounds(pObject, b1, b2) *API change*
14657 -def fl_get_scrollbar_bounds(pObject):
14658 """ 14659 fl_get_scrollbar_bounds(pObject) -> minbound, maxbound 14660 14661 Returns the bounds/limits of a scrollbar. 14662 14663 @param pObject : pointer to scrollbar object 14664 """ 14665 14666 _fl_get_scrollbar_bounds = cfuncproto( 14667 load_so_libforms(), "fl_get_scrollbar_bounds", 14668 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 14669 cty.POINTER(cty.c_double)], 14670 """void fl_get_scrollbar_bounds(FL_OBJECT * ob, double * b1, 14671 double * b2) 14672 """) 14673 minbound, pminbound = make_double_and_pointer() 14674 maxbound, pmaxbound = make_double_and_pointer() 14675 keep_elem_refs(pObject, minbound, pminbound, maxbound, pmaxbound) 14676 _fl_get_scrollbar_bounds(pObject, pminbound, pmaxbound) 14677 return minbound, maxbound
14678 14679
14680 -def fl_set_scrollbar_return(pObject, returnnum):
14681 """ 14682 fl_set_scrollbar_return(pObject, returnnum) 14683 14684 Sets the type of return of a scrollbar. 14685 14686 @param pObject : pointer to scrollbar object 14687 @param returnnum : value of return type 14688 """ 14689 14690 _fl_set_scrollbar_return = cfuncproto( 14691 load_so_libforms(), "fl_set_scrollbar_return", 14692 None, [cty.POINTER(FL_OBJECT), cty.c_int], 14693 """void fl_set_scrollbar_return(FL_OBJECT * ob, int ret) 14694 """) 14695 check_admitted_listvalues(returnnum, RETURN_list) 14696 ireturnnum = convert_to_int(returnnum) 14697 keep_elem_refs(pObject, returnnum, ireturnnum) 14698 _fl_set_scrollbar_return(pObject, ireturnnum)
14699 14700
14701 -def fl_set_scrollbar_step(pObject, step):
14702 """ fl_set_scrollbar_step(pObject, step) 14703 """ 14704 14705 _fl_set_scrollbar_step = cfuncproto( 14706 load_so_libforms(), "fl_set_scrollbar_step", 14707 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14708 """void fl_set_scrollbar_step(FL_OBJECT * ob, double step) 14709 """) 14710 fstep = convert_to_double(step) 14711 keep_elem_refs(pObject, step, fstep) 14712 _fl_set_scrollbar_step(pObject, fstep)
14713 14714 14715 14716 ##################### 14717 # forms.h (select.h) 14718 ##################### 14719 14720 # Select object types 14721
14722 -def fl_create_select(selecttype, x, y, w, h, label):
14723 """ fl_create_select(selecttype, x, y, w, h, label) -> pObject 14724 """ 14725 14726 _fl_create_select = cfuncproto( 14727 load_so_libforms(), "fl_create_select", 14728 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14729 FL_Coord, STRING], 14730 """FL_OBJECT * fl_create_select(int p1, FL_Coord p2, FL_Coord p3, 14731 FL_Coord p4, FL_Coord p5, const char * p6) 14732 """) 14733 check_admitted_listvalues(selecttype, SELECTTYPE_list) 14734 iselecttype = convert_to_int(selecttype) 14735 ix = convert_to_FL_Coord(x) 14736 iy = convert_to_FL_Coord(y) 14737 iw = convert_to_FL_Coord(w) 14738 ih = convert_to_FL_Coord(h) 14739 slabel = convert_to_string(label) 14740 keep_elem_refs(selecttype, x, y, w, h, label, iselecttype, ix, iy, 14741 iw, ih, slabel) 14742 retval = _fl_create_select(iselecttype, ix, iy, iw, ih, slabel) 14743 return retval
14744 14745
14746 -def fl_add_select(selecttype, x, y, w, h, label):
14747 """ fl_add_select(selecttype, x, y, w, h, label) -> pObject 14748 """ 14749 14750 _fl_add_select = cfuncproto( 14751 load_so_libforms(), "fl_add_select", 14752 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14753 FL_Coord, STRING], 14754 """FL_OBJECT * fl_add_select(int p1, FL_Coord p2, FL_Coord p3, 14755 FL_Coord p4, FL_Coord p5, const char * p6) 14756 """) 14757 check_admitted_listvalues(selecttype, SELECTTYPE_list) 14758 iselecttype = convert_to_int(selecttype) 14759 ix = convert_to_FL_Coord(x) 14760 iy = convert_to_FL_Coord(y) 14761 iw = convert_to_FL_Coord(w) 14762 ih = convert_to_FL_Coord(h) 14763 slabel = convert_to_string(label) 14764 keep_elem_refs(selecttype, x, y, w, h, label, iselecttype, ix, iy, 14765 iw, ih, slabel) 14766 retval = _fl_add_select(iselecttype, ix, iy, iw, ih, slabel) 14767 return retval
14768 14769
14770 -def fl_clear_select(pObject):
14771 """ fl_clear_select(pObject) 14772 14773 @param pObject : pointer to select object 14774 """ 14775 14776 _fl_clear_select = cfuncproto( 14777 load_so_libforms(), "fl_clear_select", 14778 cty.c_int, [cty.POINTER(FL_OBJECT)], 14779 """int fl_clear_select(FL_OBJECT * p1) 14780 """) 14781 keep_elem_refs(pObject) 14782 _fl_clear_select(pObject)
14783 14784
14785 -def fl_add_select_items(pObject, itemstr):
14786 """ fl_add_select_items(pObject, itemstr) -> pPopupEntry 14787 """ 14788 14789 _fl_add_select_items = cfuncproto( 14790 load_so_libforms(), "fl_add_select_items", 14791 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14792 """FL_POPUP_ENTRY * fl_add_select_items(FL_OBJECT * p1, 14793 const char * p2) 14794 """) 14795 sitemstr = convert_to_string(itemstr) 14796 keep_elem_refs(pObject, itemstr, sitemstr) 14797 retval = _fl_add_select_items(pObject, sitemstr) 14798 return retval
14799 14800
14801 -def fl_insert_select_items(pObject, pPopupEntry, itemstr):
14802 """ fl_insert_select_items(pObject, pPopupEntry, itemstr) -> pPopupEntry 14803 """ 14804 14805 _fl_insert_select_items = cfuncproto( 14806 load_so_libforms(), "fl_insert_select_items", 14807 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 14808 cty.POINTER(FL_POPUP_ENTRY), STRING], 14809 """FL_POPUP_ENTRY * fl_insert_select_items(FL_OBJECT * p1, 14810 FL_POPUP_ENTRY * p2, const char * p3) 14811 """) 14812 sitemstr = convert_to_string(itemstr) 14813 keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 14814 retval = _fl_insert_select_items(pObject, pPopupEntry, sitemstr) 14815 return retval
14816 14817
14818 -def fl_replace_select_item(pObject, pPopupEntry, itemstr):
14819 """ fl_replace_select_item(pObject, pPopupEntry, itemstr) -> pPopupEntry 14820 """ 14821 14822 _fl_replace_select_item = cfuncproto( 14823 load_so_libforms(), "fl_replace_select_item", 14824 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 14825 cty.POINTER(FL_POPUP_ENTRY), STRING], 14826 """FL_POPUP_ENTRY * fl_replace_select_item(FL_OBJECT * p1, 14827 FL_POPUP_ENTRY * p2, const char * p3) 14828 """) 14829 sitemstr = convert_to_string(itemstr) 14830 keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 14831 retval = _fl_replace_select_item(pObject, pPopupEntry, sitemstr) 14832 return retval
14833 14834
14835 -def fl_delete_select_item(pObject, pPopupEntry):
14836 """ fl_delete_select_item(pObject, pPopupEntry) -> num. 14837 """ 14838 14839 _fl_delete_select_item = cfuncproto( 14840 load_so_libforms(), "fl_delete_select_item", 14841 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ENTRY)], 14842 """int fl_delete_select_item(FL_OBJECT * p1, FL_POPUP_ENTRY * p2) 14843 """) 14844 keep_elem_refs(pObject, pPopupEntry) 14845 retval = _fl_delete_select_item(pObject, pPopupEntry) 14846 return retval
14847 14848
14849 -def fl_set_select_items(pObject, pPopupItem):
14850 """ 14851 fl_set_select_items(pObject, pPopupItem) -> num. 14852 14853 Repopulates a select object popup. 14854 14855 @param pObject : pointer to select object 14856 @param pPopupItem : pointer to xfc.FL_POPUP_ITEM structure 14857 """ 14858 14859 _fl_set_select_items = cfuncproto( 14860 load_so_libforms(), "fl_set_select_items", 14861 cty.c_long, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ITEM)], 14862 """long int fl_set_select_items(FL_OBJECT * p1, 14863 FL_POPUP_ITEM * p2) 14864 """) 14865 #pPopupItem.callback = FL_POPUP_CB() 14866 keep_elem_refs(pObject, pPopupItem) 14867 retval = _fl_set_select_items(pObject, pPopupItem) 14868 return retval
14869 14870
14871 -def fl_get_select_popup(pObject):
14872 """ fl_get_select_popup(pObject) -> pPopup 14873 """ 14874 14875 _fl_get_select_popup = cfuncproto( 14876 load_so_libforms(), "fl_get_select_popup", 14877 cty.POINTER(FL_POPUP), [cty.POINTER(FL_OBJECT)], 14878 """FL_POPUP * fl_get_select_popup(FL_OBJECT * p1) 14879 """) 14880 keep_elem_refs(pObject) 14881 retval = _fl_get_select_popup(pObject) 14882 return retval
14883 14884
14885 -def fl_set_select_popup(pObject, pPopup):
14886 """ fl_set_select_popup(pObject, pPopup) -> num. 14887 """ 14888 14889 _fl_set_select_popup = cfuncproto( 14890 load_so_libforms(), "fl_set_select_popup", 14891 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP)], 14892 """int fl_set_select_popup(FL_OBJECT * p1, FL_POPUP * p2) 14893 """) 14894 keep_elem_refs(pObject, pPopup) 14895 retval = _fl_set_select_popup(pObject, pPopup) 14896 return retval
14897 14898
14899 -def fl_get_select_item(pObject):
14900 """ fl_get_select_item(pObject) -> pPopupReturn 14901 """ 14902 14903 _fl_get_select_item = cfuncproto( 14904 load_so_libforms(), "fl_get_select_item", 14905 cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT)], 14906 """FL_POPUP_RETURN * fl_get_select_item(FL_OBJECT * p1) 14907 """) 14908 keep_elem_refs(pObject) 14909 retval = _fl_get_select_item(pObject) 14910 return retval
14911 14912
14913 -def fl_set_select_item(pObject, pPopupEntry):
14914 """ fl_set_select_item(pObject, pPopupEntry) -> pPopupReturn 14915 """ 14916 14917 _fl_set_select_item = cfuncproto( 14918 load_so_libforms(), "fl_set_select_item", 14919 cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT), 14920 cty.POINTER(FL_POPUP_ENTRY)], 14921 """FL_POPUP_RETURN * fl_set_select_item(FL_OBJECT * p1, 14922 FL_POPUP_ENTRY * p2) 14923 """) 14924 keep_elem_refs(pObject, pPopupEntry) 14925 retval = _fl_set_select_item(pObject, pPopupEntry) 14926 return retval
14927 14928
14929 -def fl_get_select_item_by_value(pObject, value):
14930 """ fl_get_select_item_by_value(pObject, value) -> pPopupEntry 14931 """ 14932 14933 _fl_get_select_item_by_value = cfuncproto( 14934 load_so_libforms(), "fl_get_select_item_by_value", 14935 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), cty.c_long], 14936 """FL_POPUP_ENTRY * fl_get_select_item_by_value(FL_OBJECT * p1, 14937 long int p2) 14938 """) 14939 lvalue = convert_to_long(value) 14940 keep_elem_refs(pObject, value, lvalue) 14941 retval = _fl_get_select_item_by_value(pObject, lvalue) 14942 return retval
14943 14944
14945 -def fl_get_select_item_by_label(pObject, label):
14946 """ fl_get_select_item_by_label(pObject, label) -> pPopupEntry 14947 """ 14948 14949 _fl_get_select_item_by_label = cfuncproto( 14950 load_so_libforms(), "fl_get_select_item_by_label", 14951 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14952 """FL_POPUP_ENTRY * fl_get_select_item_by_label(FL_OBJECT * p1, 14953 const char * p2) 14954 """) 14955 slabel = convert_to_string(label) 14956 keep_elem_refs(pObject, label, slabel) 14957 retval = _fl_get_select_item_by_label(pObject, slabel) 14958 return retval
14959 14960
14961 -def fl_get_select_item_by_text(pObject, txtstr):
14962 """ fl_get_select_item_by_text(pObject, txtstr) -> pPopupEntry 14963 """ 14964 14965 _fl_get_select_item_by_text = cfuncproto( 14966 load_so_libforms(), "fl_get_select_item_by_text", 14967 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14968 """FL_POPUP_ENTRY * fl_get_select_item_by_text(FL_OBJECT * p1, 14969 const char * p2) 14970 """) 14971 stxtstr = convert_to_string(txtstr) 14972 keep_elem_refs(pObject, txtstr, stxtstr) 14973 retval = _fl_get_select_item_by_text(pObject, stxtstr) 14974 return retval
14975 14976
14977 -def fl_get_select_text_color(pObject):
14978 """ fl_get_select_text_color(pObject) -> color 14979 """ 14980 14981 _fl_get_select_text_color = cfuncproto( 14982 load_so_libforms(), "fl_get_select_text_color", 14983 FL_COLOR, [cty.POINTER(FL_OBJECT)], 14984 """FL_COLOR fl_get_select_text_color(FL_OBJECT * p1) 14985 """) 14986 keep_elem_refs(pObject) 14987 retval = _fl_get_select_text_color(pObject) 14988 return retval
14989 14990
14991 -def fl_set_select_text_color(pObject, colr):
14992 """ fl_set_select_text_color(pObject, colr) -> color 14993 """ 14994 14995 _fl_set_select_text_color = cfuncproto( 14996 load_so_libforms(), "fl_set_select_text_color", 14997 FL_COLOR, [cty.POINTER(FL_OBJECT), FL_COLOR], 14998 """FL_COLOR fl_set_select_text_color(FL_OBJECT * p1, FL_COLOR p2) 14999 """) 15000 ulcolr = convert_to_FL_COLOR(colr) 15001 keep_elem_refs(pObject, colr, ulcolr) 15002 retval = _fl_set_select_text_color(pObject, ulcolr) 15003 return retval
15004 15005 15006 #def fl_get_select_text_font(pObject, p2, p3) *API change*
15007 -def fl_get_select_text_font(pObject):
15008 """ fl_get_select_text_font(pObject) -> num, num1, num2 15009 """ 15010 15011 _fl_get_select_text_font = cfuncproto( 15012 load_so_libforms(), "fl_get_select_text_font", 15013 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 15014 cty.POINTER(cty.c_int)], 15015 """int fl_get_select_text_font(FL_OBJECT * p1, int * p2, int * p3) 15016 """) 15017 num1, pnum1 = make_int_and_pointer() 15018 num2, pnum2 = make_int_and_pointer() 15019 keep_elem_refs(pObject, num1, num2, pnum1, pnum2) 15020 retval = _fl_get_select_text_font(pObject, pnum2, pnum2) 15021 return retval, num1, num2
15022 15023
15024 -def fl_set_select_text_font(pObject, p2, p3):
15025 """ fl_set_select_text_font(pObject, p2, p3) -> font num. 15026 """ 15027 15028 _fl_set_select_text_font = cfuncproto( 15029 load_so_libforms(), "fl_set_select_text_font", 15030 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 15031 """int fl_set_select_text_font(FL_OBJECT * p1, int p2, int p3) 15032 """) 15033 ip2 = convert_to_int(p2) 15034 ip3 = convert_to_int(p3) 15035 keep_elem_refs(pObject, p2, p3, ip2, ip3) 15036 retval = _fl_set_select_text_font(pObject, ip2, ip3) 15037 return retval
15038 15039
15040 -def fl_get_select_text_align(pObject):
15041 """ fl_get_select_text_align(pObject) -> num. 15042 """ 15043 15044 _fl_get_select_text_align = cfuncproto( 15045 load_so_libforms(), "fl_get_select_text_align", 15046 cty.c_int, [cty.POINTER(FL_OBJECT)], 15047 """int fl_get_select_text_align(FL_OBJECT * p1) 15048 """) 15049 keep_elem_refs(pObject) 15050 retval = _fl_get_select_text_align(pObject) 15051 return retval
15052 15053
15054 -def fl_set_select_text_align(pObject, p2):
15055 """ fl_set_select_text_align(pObject, p2) -> num. 15056 """ 15057 15058 _fl_set_select_text_align = cfuncproto( 15059 load_so_libforms(), "fl_set_select_text_align", 15060 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 15061 """int fl_set_select_text_align(FL_OBJECT * p1, int p2) 15062 """) 15063 ip2 = convert_to_int(p2) 15064 keep_elem_refs(pObject, p2, ip2) 15065 retval = _fl_set_select_text_align(pObject, ip2) 15066 return retval
15067 15068
15069 -def fl_set_select_policy(pObject, num):
15070 """ fl_set_select_policy(pObject, num) -> num. 15071 """ 15072 15073 _fl_set_select_policy = cfuncproto( 15074 load_so_libforms(), "fl_set_select_policy", 15075 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 15076 """int fl_set_select_policy(FL_OBJECT * p1, int p2) 15077 """) 15078 inum = convert_to_int(num) 15079 keep_elem_refs(pObject, num, inum) 15080 retval = _fl_set_select_policy(pObject, inum) 15081 return retval
15082 15083 15084 15085 ####################### 15086 # forms.h (slider.h) 15087 # Object Class: Slider 15088 ####################### 15089 15090 # Routines 15091
15092 -def fl_create_slider(slidertype, x, y, w, h, label):
15093 """ fl_create_slider(slidertype, x, y, w, h, label) -> pObject 15094 """ 15095 15096 _fl_create_slider = cfuncproto( 15097 load_so_libforms(), "fl_create_slider", 15098 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15099 FL_Coord, STRING], 15100 """FL_OBJECT * fl_create_slider(int type, FL_Coord x, FL_Coord y, 15101 FL_Coord w, FL_Coord h, const char * label) 15102 """) 15103 check_admitted_listvalues(slidertype, SLIDERTYPE_list) 15104 islidertype = convert_to_int(slidertype) 15105 ix = convert_to_FL_Coord(x) 15106 iy = convert_to_FL_Coord(y) 15107 iw = convert_to_FL_Coord(w) 15108 ih = convert_to_FL_Coord(h) 15109 slabel = convert_to_string(label) 15110 keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 15111 iw, ih, slabel) 15112 retval = _fl_create_slider(islidertype, ix, iy, iw, ih, slabel) 15113 return retval
15114 15115
15116 -def fl_add_slider(slidertype, x, y, w, h, label):
15117 """ 15118 fl_add_slider(slidertype, x, y, w, h, label) -> pObject 15119 15120 Adds a slider to a form. No value is displayed. 15121 15122 @param slidertype : type of the slider 15123 @param x : horizontal position (upper-left corner) 15124 @param y : vertical position (upper-left corner) 15125 @param w : width of the slider 15126 @param h : height of the slider 15127 @param label : label of the slider (placed below it by default) 15128 """ 15129 15130 _fl_add_slider = cfuncproto( 15131 load_so_libforms(), "fl_add_slider", 15132 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15133 FL_Coord, STRING], 15134 """FL_OBJECT * fl_add_slider(int type, FL_Coord x, FL_Coord y, 15135 FL_Coord w, FL_Coord h, const char * label) 15136 """) 15137 check_admitted_listvalues(slidertype, SLIDERTYPE_list) 15138 islidertype = convert_to_int(slidertype) 15139 ix = convert_to_FL_Coord(x) 15140 iy = convert_to_FL_Coord(y) 15141 iw = convert_to_FL_Coord(w) 15142 ih = convert_to_FL_Coord(h) 15143 slabel = convert_to_string(label) 15144 keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 15145 iw, ih, slabel) 15146 retval = _fl_add_slider(islidertype, ix, iy, iw, ih, slabel) 15147 return retval
15148 15149
15150 -def fl_create_valslider(slidertype, x, y, w, h, label):
15151 """ fl_create_valslider(slidertype, x, y, w, h, label) -> pObject 15152 """ 15153 15154 _fl_create_valslider = cfuncproto( 15155 load_so_libforms(), "fl_create_valslider", 15156 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15157 FL_Coord, STRING], 15158 """FL_OBJECT * fl_create_valslider(int type, FL_Coord x, 15159 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 15160 """) 15161 check_admitted_listvalues(slidertype, SLIDERTYPE_list) 15162 islidertype = convert_to_int(slidertype) 15163 ix = convert_to_FL_Coord(x) 15164 iy = convert_to_FL_Coord(y) 15165 iw = convert_to_FL_Coord(w) 15166 ih = convert_to_FL_Coord(h) 15167 slabel = convert_to_string(label) 15168 keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 15169 iw, ih, slabel) 15170 retval = _fl_create_valslider(islidertype, ix, iy, iw, ih, slabel) 15171 return retval
15172 15173
15174 -def fl_add_valslider(slidertype, x, y, w, h, label):
15175 """ 15176 fl_add_valslider(slidertype, x, y, w, h, label) -> pObject 15177 15178 Adds a slider to a form. Its value is displayed above or to the 15179 left of the slider. 15180 15181 @param slidertype : type of the slider 15182 @param x : horizontal position (upper-left corner) 15183 @param y : vertical position (upper-left corner) 15184 @param w : width of the slider 15185 @param h : height of the slider 15186 @param label : label of the slider (placed below it by default) 15187 """ 15188 15189 _fl_add_valslider = cfuncproto( 15190 load_so_libforms(), "fl_add_valslider", 15191 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15192 FL_Coord, STRING], 15193 """FL_OBJECT * fl_add_valslider(int type, FL_Coord x, FL_Coord y, 15194 FL_Coord w, FL_Coord h, const char * label) 15195 """) 15196 check_admitted_listvalues(slidertype, SLIDERTYPE_list) 15197 islidertype = convert_to_int(slidertype) 15198 ix = convert_to_FL_Coord(x) 15199 iy = convert_to_FL_Coord(y) 15200 iw = convert_to_FL_Coord(w) 15201 ih = convert_to_FL_Coord(h) 15202 slabel = convert_to_string(label) 15203 keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 15204 iw, ih, slabel) 15205 retval = _fl_add_valslider(islidertype, ix, iy, iw, ih, slabel) 15206 return retval
15207 15208
15209 -def fl_set_slider_value(pObject, val):
15210 """ 15211 fl_set_slider_value(pObject, val) 15212 15213 Changes the value of a slider. 15214 15215 @param pObject : pointer to object 15216 @param val : new value of slider 15217 """ 15218 15219 _fl_set_slider_value = cfuncproto( 15220 load_so_libforms(), "fl_set_slider_value", 15221 None, [cty.POINTER(FL_OBJECT), cty.c_double], 15222 """void fl_set_slider_value(FL_OBJECT * ob, double val) 15223 """) 15224 fval = convert_to_double(val) 15225 keep_elem_refs(pObject, val, fval) 15226 _fl_set_slider_value(pObject, fval)
15227 15228
15229 -def fl_get_slider_value(pObject):
15230 """ 15231 fl_get_slider_value(pObject) -> value[float] 15232 15233 Returns value of a slider. 15234 15235 @param pObject : pointer to object 15236 """ 15237 15238 _fl_get_slider_value = cfuncproto( 15239 load_so_libforms(), "fl_get_slider_value", 15240 cty.c_double, [cty.POINTER(FL_OBJECT)], 15241 """double fl_get_slider_value(FL_OBJECT * ob) 15242 """) 15243 keep_elem_refs(pObject) 15244 retval = _fl_get_slider_value(pObject) 15245 return retval
15246 15247
15248 -def fl_set_slider_bounds(pObject, minbound, maxbound):
15249 """ 15250 fl_set_slider_bounds(pObject, minbound, maxbound) 15251 15252 Sets bounds/limits of a slider. 15253 15254 @param pObject : pointer to object 15255 @param minbound : minimum bound of slider 15256 @param maxbound : maximum bound of slider 15257 """ 15258 15259 _fl_set_slider_bounds = cfuncproto( 15260 load_so_libforms(), "fl_set_slider_bounds", 15261 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 15262 """void fl_set_slider_bounds(FL_OBJECT * ob, double min, 15263 double max) 15264 """) 15265 fminbound = convert_to_double(minbound) 15266 fmaxbound = convert_to_double(maxbound) 15267 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 15268 _fl_set_slider_bounds(pObject, fminbound, fmaxbound)
15269 15270 15271 #def fl_get_slider_bounds(pObject, minbound, maxbound) *API change*
15272 -def fl_get_slider_bounds(pObject):
15273 """ 15274 fl_get_slider_bounds(pObject) -> minbound[float], maxbound[float] 15275 15276 Returns bounds/limits of a slider. 15277 15278 @param pObject : pointer to object 15279 """ 15280 15281 _fl_get_slider_bounds = cfuncproto( 15282 load_so_libforms(), "fl_get_slider_bounds", 15283 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 15284 cty.POINTER(cty.c_double)], 15285 """void fl_get_slider_bounds(FL_OBJECT * ob, double * min, 15286 double * max) 15287 """) 15288 minbound, pminbound = make_double_and_pointer() 15289 maxbound, pmaxbound = make_double_and_pointer() 15290 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 15291 _fl_get_slider_bounds(pObject, pminbound, pmaxbound) 15292 return minbound, maxbound
15293 15294
15295 -def fl_set_slider_return(pObject, returnnum):
15296 """ 15297 fl_set_slider_return(pObject, returnnum) 15298 15299 Sets the return value of a slider. 15300 15301 @param pObject : pointer to object 15302 @param returnnum : value of return (e.g. xfc.FL_RETURN_NONE, etc..) 15303 """ 15304 15305 _fl_set_slider_return = cfuncproto( 15306 load_so_libforms(), "fl_set_slider_return", 15307 None, [cty.POINTER(FL_OBJECT), cty.c_int], 15308 """void fl_set_slider_return(FL_OBJECT * ob, int value) 15309 """) 15310 check_admitted_listvalues(returnnum, RETURN_list) 15311 ireturnnum = convert_to_int(returnnum) 15312 keep_elem_refs(pObject, returnnum, ireturnnum) 15313 _fl_set_slider_return(pObject, ireturnnum)
15314 15315
15316 -def fl_set_slider_step(pObject, value):
15317 """ fl_set_slider_step(pObject, value) 15318 """ 15319 15320 _fl_set_slider_step = cfuncproto( 15321 load_so_libforms(), "fl_set_slider_step", 15322 None, [cty.POINTER(FL_OBJECT), cty.c_double], 15323 """void fl_set_slider_step(FL_OBJECT * ob, double value) 15324 """) 15325 fvalue = convert_to_double(value) 15326 keep_elem_refs(pObject, value, fvalue) 15327 _fl_set_slider_step(pObject, fvalue)
15328 15329
15330 -def fl_set_slider_increment(pObject, leftbtnval, midlbtnval):
15331 """ fl_set_slider_increment(pObject, leftbtnval, midlbtnval) 15332 """ 15333 15334 _fl_set_slider_increment = cfuncproto( 15335 load_so_libforms(), "fl_set_slider_increment", 15336 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 15337 """void fl_set_slider_increment(FL_OBJECT * ob, double l, 15338 double r) 15339 """) 15340 fleftbtnval = convert_to_double(leftbtnval) 15341 fmidlbtnval = convert_to_double(midlbtnval) 15342 keep_elem_refs(pObject, leftbtnval, midlbtnval, fleftbtnval, fmidlbtnval) 15343 _fl_set_slider_increment(pObject, fleftbtnval, fmidlbtnval)
15344 15345 15346 #def fl_get_slider_increment(pObject, leftbtnval, midlbtnval) *API change*
15347 -def fl_get_slider_increment(pObject):
15348 """ fl_get_slider_increment(pObject) -> leftbtnval, midlbtnval 15349 """ 15350 15351 _fl_get_slider_increment = cfuncproto( 15352 load_so_libforms(), "fl_get_slider_increment", 15353 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 15354 cty.POINTER(cty.c_double)], \ 15355 """void fl_get_slider_increment(FL_OBJECT * ob, double * l, 15356 double * r) 15357 """) 15358 leftbtnval, pleftbtnval = make_double_and_pointer() 15359 midlbtnval, pmidlbtnval = make_double_and_pointer() 15360 keep_elem_refs(pObject, leftbtnval, midlbtnval, pleftbtnval, pmidlbtnval) 15361 _fl_get_slider_increment(pObject, pleftbtnval, pmidlbtnval) 15362 return leftbtnval, midlbtnval
15363 15364
15365 -def fl_set_slider_size(pObject, size):
15366 """ 15367 fl_set_slider_size(pObject, size) 15368 15369 Sets the size of a slider. 15370 15371 @param pObject : pointer to object 15372 @param size : value of size of the slider 15373 """ 15374 15375 _fl_set_slider_size = cfuncproto( 15376 load_so_libforms(), "fl_set_slider_size", 15377 None, [cty.POINTER(FL_OBJECT), cty.c_double], 15378 """void fl_set_slider_size(FL_OBJECT * ob, double size) 15379 """) 15380 fsize = convert_to_double(size) 15381 keep_elem_refs(pObject, size, fsize) 15382 _fl_set_slider_size(pObject, fsize)
15383 15384
15385 -def fl_set_slider_precision(pObject, precnum):
15386 """ 15387 fl_set_slider_precision(pObject, precnum) 15388 15389 Sets precision with which value a valslider is shown. 15390 15391 @param pObject : pointer to object 15392 @param precnum : precision of shown value 15393 """ 15394 15395 _fl_set_slider_precision = cfuncproto( 15396 load_so_libforms(), "fl_set_slider_precision", 15397 None, [cty.POINTER(FL_OBJECT), cty.c_int], 15398 """void fl_set_slider_precision(FL_OBJECT * ob, int prec) 15399 """) 15400 iprecnum = convert_to_int(precnum) 15401 keep_elem_refs(pObject, precnum, iprecnum) 15402 _fl_set_slider_precision(pObject, iprecnum)
15403 15404
15405 -def fl_set_slider_filter(pObject, py_ValFilter):
15406 """ 15407 fl_set_slider_filter(pObject, py_ValFilter) 15408 15409 Overrides the default (slider value shown in floating point format) 15410 by registering a filter function. 15411 15412 @param pObject : pointer to oject 15413 @param py_ValFilter : python function, fn(pObject, valfloat, 15414 intprecis) -> string 15415 """ 15416 15417 _fl_set_slider_filter = cfuncproto( 15418 load_so_libforms(), "fl_set_slider_filter", 15419 None, [cty.POINTER(FL_OBJECT), FL_VAL_FILTER], 15420 """void fl_set_slider_filter(FL_OBJECT * ob, FL_VAL_FILTER filter) 15421 """) 15422 c_ValFilter = FL_VAL_FILTER(py_ValFilter) 15423 keep_cfunc_refs(c_ValFilter, py_ValFilter) 15424 keep_elem_refs(pObject) 15425 _fl_set_slider_filter(pObject, c_ValFilter)
15426 15427
15428 -def fl_create_spinner(spinnertype, x, y, w, h, label):
15429 """ fl_create_spinner(spinnertype, x, y, w, h, label) -> pObject 15430 """ 15431 15432 _fl_create_spinner = cfuncproto( 15433 load_so_libforms(), "fl_create_spinner", 15434 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15435 FL_Coord, STRING], 15436 """FL_OBJECT * fl_create_spinner(int type, FL_Coord x, FL_Coord y, 15437 FL_Coord w, FL_Coord h, const char * label) 15438 """) 15439 check_admitted_listvalues(spinnertype, SPINNERTYPE_list) 15440 ispinnertype = convert_to_int(spinnertype) 15441 ix = convert_to_FL_Coord(x) 15442 iy = convert_to_FL_Coord(y) 15443 iw = convert_to_FL_Coord(w) 15444 ih = convert_to_FL_Coord(h) 15445 slabel = convert_to_string(label) 15446 keep_elem_refs(spinnertype, x, y, w, h, label, ispinnertype, ix, iy, 15447 iw, ih, slabel) 15448 retval = _fl_create_spinner(ispinnertype, ix, iy, iw, ih, slabel) 15449 return retval
15450 15451
15452 -def fl_add_spinner(spinnertype, x, y, w, h, label):
15453 """ fl_add_spinner(spinnertype, x, y, w, h, label) -> pObject 15454 """ 15455 15456 _fl_add_spinner = cfuncproto( 15457 load_so_libforms(), "fl_add_spinner", 15458 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15459 FL_Coord, STRING], 15460 """FL_OBJECT * fl_add_spinner(int type, FL_Coord x, FL_Coord y, 15461 FL_Coord w, FL_Coord h, const char * label) 15462 """) 15463 check_admitted_listvalues(spinnertype, SPINNERTYPE_list) 15464 ispinnertype = convert_to_int(spinnertype) 15465 ix = convert_to_FL_Coord(x) 15466 iy = convert_to_FL_Coord(y) 15467 iw = convert_to_FL_Coord(w) 15468 ih = convert_to_FL_Coord(h) 15469 slabel = convert_to_string(label) 15470 keep_elem_refs(spinnertype, x, y, w, h, label, ispinnertype, ix, iy, 15471 iw, ih, slabel) 15472 retval = _fl_add_spinner(ispinnertype, ix, iy, iw, ih, slabel) 15473 return retval
15474 15475
15476 -def fl_get_spinner_value(pObject):
15477 """ fl_get_spinner_value(pObject) -> floatval 15478 """ 15479 15480 _fl_get_spinner_value = cfuncproto( 15481 load_so_libforms(), "fl_get_spinner_value", 15482 cty.c_double, [cty.POINTER(FL_OBJECT)], 15483 """double fl_get_spinner_value(FL_OBJECT * obj) 15484 """) 15485 keep_elem_refs(pObject) 15486 retval = _fl_get_spinner_value(pObject) 15487 return retval
15488 15489
15490 -def fl_set_spinner_value(pObject, val):
15491 """ fl_set_spinner_value(pObject, val) -> num. 15492 """ 15493 15494 _fl_set_spinner_value = cfuncproto( 15495 load_so_libforms(), "fl_set_spinner_value", 15496 cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 15497 """double fl_set_spinner_value(FL_OBJECT * obj, double val) 15498 """) 15499 fval = convert_to_double(val) 15500 keep_elem_refs(pObject, val, fval) 15501 _fl_set_spinner_value(pObject, fval)
15502 15503
15504 -def fl_set_spinner_bounds(pObject, minbound, maxbound):
15505 """ fl_set_spinner_bounds(pObject, minbound, maxbound) 15506 """ 15507 15508 _fl_set_spinner_bounds = cfuncproto( 15509 load_so_libforms(), "fl_set_spinner_bounds", 15510 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 15511 """void fl_set_spinner_bounds(FL_OBJECT * obj, double min, 15512 double max) 15513 """) 15514 fminbound = convert_to_double(minbound) 15515 fmaxbound = convert_to_double(maxbound) 15516 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 15517 _fl_set_spinner_bounds(pObject, fminbound, fmaxbound)
15518 15519 15520 #def fl_get_spinner_bounds(pObject, minbound, maxbound): *API change*
15521 -def fl_get_spinner_bounds(pObject):
15522 """ fl_get_spinner_bounds(pObject) -> minbound, maxbound 15523 """ 15524 15525 _fl_get_spinner_bounds = cfuncproto( 15526 load_so_libforms(), "fl_get_spinner_bounds", 15527 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 15528 cty.POINTER(cty.c_double)], \ 15529 """void fl_get_spinner_bounds(FL_OBJECT * obj, double * min, 15530 double * max) 15531 """) 15532 minbound, pminbound = make_double_and_pointer() 15533 maxbound, pmaxbound = make_double_and_pointer() 15534 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 15535 _fl_get_spinner_bounds(pObject, pminbound, pmaxbound) 15536 return minbound, maxbound
15537 15538
15539 -def fl_set_spinner_step(pObject, step):
15540 """ fl_set_spinner_step(pObject, step) 15541 """ 15542 15543 _fl_set_spinner_step = cfuncproto( 15544 load_so_libforms(), "fl_set_spinner_step", 15545 None, [cty.POINTER(FL_OBJECT), cty.c_double], 15546 """void fl_set_spinner_step(FL_OBJECT * obj, double step) 15547 """) 15548 fstep = convert_to_double(step) 15549 keep_elem_refs(pObject, step, fstep) 15550 _fl_set_spinner_step(pObject, fstep)
15551 15552
15553 -def fl_get_spinner_step(pObject):
15554 """ fl_get_spinner_step(pObject) -> num. 15555 """ 15556 15557 _fl_get_spinner_step = cfuncproto( 15558 load_so_libforms(), "fl_get_spinner_step", 15559 cty.c_double, [cty.POINTER(FL_OBJECT)], 15560 """double fl_get_spinner_step(FL_OBJECT * obj) 15561 """) 15562 keep_elem_refs(pObject) 15563 retval = _fl_get_spinner_step(pObject) 15564 return retval
15565 15566
15567 -def fl_set_spinner_precision(pObject, precnum):
15568 """ fl_set_spinner_precision(pObject, precnum) 15569 """ 15570 15571 _fl_set_spinner_precision = cfuncproto( 15572 load_so_libforms(), "fl_set_spinner_precision", 15573 None, [cty.POINTER(FL_OBJECT), cty.c_int], 15574 """void fl_set_spinner_precision(FL_OBJECT * obj, int prec) 15575 """) 15576 iprecnum = convert_to_int(precnum) 15577 keep_elem_refs(pObject, precnum, iprecnum) 15578 _fl_set_spinner_precision(pObject, iprecnum)
15579 15580
15581 -def fl_get_spinner_precision(pObject):
15582 """ fl_get_spinner_precision(pObject) -> num. 15583 """ 15584 15585 _fl_get_spinner_precision = cfuncproto( 15586 load_so_libforms(), "fl_get_spinner_precision", 15587 cty.c_int, [cty.POINTER(FL_OBJECT)], 15588 """int fl_get_spinner_precision(FL_OBJECT * obj) 15589 """) 15590 keep_elem_refs(pObject) 15591 retval = _fl_get_spinner_precision(pObject) 15592 return retval
15593 15594
15595 -def fl_get_spinner_input(pObject):
15596 """ fl_get_spinner_input(pObject) -> pObject 15597 """ 15598 15599 _fl_get_spinner_input = cfuncproto( 15600 load_so_libforms(), "fl_get_spinner_input", 15601 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 15602 """FL_OBJECT * fl_get_spinner_input(FL_OBJECT * obj) 15603 """) 15604 keep_elem_refs(pObject) 15605 retval = _fl_get_spinner_input(pObject) 15606 return retval
15607 15608
15609 -def fl_get_spinner_up_button(pObject):
15610 """ fl_get_spinner_up_button(pObject) -> pObject 15611 """ 15612 15613 _fl_get_spinner_up_button = cfuncproto( 15614 load_so_libforms(), "fl_get_spinner_up_button", 15615 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 15616 """FL_OBJECT * fl_get_spinner_up_button(FL_OBJECT * obj) 15617 """) 15618 keep_elem_refs(pObject) 15619 retval = _fl_get_spinner_up_button(pObject) 15620 return retval
15621 15622
15623 -def fl_get_spinner_down_button(pObject):
15624 """ fl_get_spinner_down_button(pObject) -> pObject 15625 """ 15626 15627 _fl_get_spinner_down_button = cfuncproto( 15628 load_so_libforms(), "fl_get_spinner_down_button", 15629 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 15630 """FL_OBJECT * fl_get_spinner_down_button(FL_OBJECT * obj) 15631 """) 15632 keep_elem_refs(pObject) 15633 retval = _fl_get_spinner_down_button(pObject) 15634 return retval
15635 15636 15637 15638 ######################## 15639 # forms.h (tabfolder.h) 15640 ######################## 15641
15642 -def fl_create_tabfolder(foldertype, x, y, w, h, label):
15643 """ fl_create_tabfolder(foldertype, x, y, w, h, label) -> pObject 15644 """ 15645 15646 _fl_create_tabfolder = cfuncproto( 15647 load_so_libforms(), "fl_create_tabfolder", 15648 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15649 FL_Coord, STRING], 15650 """FL_OBJECT * fl_create_tabfolder(int type, FL_Coord x, 15651 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 15652 """) 15653 check_admitted_listvalues(foldertype, TABFOLDERTYPE_list) 15654 ifoldertype = convert_to_int(foldertype) 15655 ix = convert_to_FL_Coord(x) 15656 iy = convert_to_FL_Coord(y) 15657 iw = convert_to_FL_Coord(w) 15658 ih = convert_to_FL_Coord(h) 15659 slabel = convert_to_string(label) 15660 keep_elem_refs(foldertype, x, y, w, h, label, ifoldertype, ix, iy, 15661 iw, ih, slabel) 15662 retval = _fl_create_tabfolder(ifoldertype, ix, iy, iw, ih, slabel) 15663 return retval
15664 15665
15666 -def fl_add_tabfolder(foldertype, x, y, w, h, label):
15667 """ fl_add_tabfolder(foldertype, x, y, w, h, label) -> pObject 15668 """ 15669 15670 _fl_add_tabfolder = cfuncproto( 15671 load_so_libforms(), "fl_add_tabfolder", 15672 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15673 FL_Coord, STRING], 15674 """FL_OBJECT * fl_add_tabfolder(int type, FL_Coord x, FL_Coord y, 15675 FL_Coord w, FL_Coord h, const char * label) 15676 """) 15677 check_admitted_listvalues(foldertype, TABFOLDERTYPE_list) 15678 ifoldertype = convert_to_int(foldertype) 15679 ix = convert_to_FL_Coord(x) 15680 iy = convert_to_FL_Coord(y) 15681 iw = convert_to_FL_Coord(w) 15682 ih = convert_to_FL_Coord(h) 15683 slabel = convert_to_string(label) 15684 keep_elem_refs(foldertype, x, y, w, h, label, ifoldertype, ix, iy, 15685 iw, ih, slabel) 15686 retval = _fl_add_tabfolder(ifoldertype, ix, iy, iw, ih, slabel) 15687 return retval
15688 15689
15690 -def fl_addto_tabfolder(pObject, title, pForm):
15691 """ fl_addto_tabfolder(pObject, title, pForm) -> pObject 15692 """ 15693 15694 _fl_addto_tabfolder = cfuncproto( 15695 load_so_libforms(), "fl_addto_tabfolder", 15696 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT), STRING, 15697 cty.POINTER(FL_FORM)], 15698 """FL_OBJECT * fl_addto_tabfolder(FL_OBJECT * ob, 15699 const char * title, FL_FORM * form) 15700 """) 15701 stitle = convert_to_string(title) 15702 keep_elem_refs(pObject, title, pForm, stitle) 15703 retval = _fl_addto_tabfolder(pObject, stitle, pForm) 15704 return retval
15705 15706
15707 -def fl_get_tabfolder_folder_bynumber(pObject, num):
15708 """ fl_get_tabfolder_folder_bynumber(pObject, num) -> pForm 15709 """ 15710 15711 _fl_get_tabfolder_folder_bynumber = cfuncproto( 15712 load_so_libforms(), "fl_get_tabfolder_folder_bynumber", 15713 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 15714 """FL_FORM * fl_get_tabfolder_folder_bynumber(FL_OBJECT * ob, 15715 int num) 15716 """) 15717 inum = convert_to_int(num) 15718 keep_elem_refs(pObject, num, inum) 15719 retval = _fl_get_tabfolder_folder_bynumber(pObject, inum) 15720 return retval
15721 15722
15723 -def fl_get_tabfolder_folder_byname(pObject, name):
15724 """ fl_get_tabfolder_folder_byname(pObject, name) -> pForm 15725 """ 15726 15727 _fl_get_tabfolder_folder_byname = cfuncproto( 15728 load_so_libforms(), "fl_get_tabfolder_folder_byname", 15729 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), STRING], 15730 """FL_FORM * fl_get_tabfolder_folder_byname(FL_OBJECT * ob, 15731 const char * name) 15732 """) 15733 sname = convert_to_string(name) 15734 keep_elem_refs(pObject, name, sname) 15735 retval = _fl_get_tabfolder_folder_byname(pObject, sname) 15736 return retval
15737 15738
15739 -def fl_delete_folder(pObject, pForm):
15740 """ fl_delete_folder(pObject, pForm) 15741 """ 15742 15743 _fl_delete_folder = cfuncproto( 15744 load_so_libforms(), "fl_delete_folder", 15745 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 15746 """void fl_delete_folder(FL_OBJECT * ob, FL_FORM * form) 15747 """) 15748 keep_elem_refs(pObject, pForm) 15749 _fl_delete_folder(pObject, pForm)
15750 15751
15752 -def fl_delete_folder_bynumber(pObject, num):
15753 """ fl_delete_folder_bynumber(pObject, num) 15754 """ 15755 15756 _fl_delete_folder_bynumber = cfuncproto( 15757 load_so_libforms(), "fl_delete_folder_bynumber", 15758 None, [cty.POINTER(FL_OBJECT), cty.c_int], 15759 """void fl_delete_folder_bynumber(FL_OBJECT * ob, int num) 15760 """) 15761 inum = convert_to_int(num) 15762 keep_elem_refs(pObject, num, inum) 15763 _fl_delete_folder_bynumber(pObject, inum)
15764 15765
15766 -def fl_delete_folder_byname(pObject, name):
15767 """ fl_delete_folder_byname(pObject, name) 15768 """ 15769 15770 _fl_delete_folder_byname = cfuncproto( 15771 load_so_libforms(), "fl_delete_folder_byname", 15772 None, [cty.POINTER(FL_OBJECT), STRING], 15773 """void fl_delete_folder_byname(FL_OBJECT * ob, const char * name) 15774 """) 15775 sname = convert_to_string(name) 15776 keep_elem_refs(pObject, name, sname) 15777 _fl_delete_folder_byname(pObject, sname)
15778 15779
15780 -def fl_set_folder(pObject, pForm):
15781 """ fl_set_folder(pObject, pForm) 15782 """ 15783 15784 _fl_set_folder = cfuncproto( 15785 load_so_libforms(), "fl_set_folder", 15786 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 15787 """void fl_set_folder(FL_OBJECT * ob, FL_FORM * form) 15788 """) 15789 keep_elem_refs(pObject, pForm) 15790 _fl_set_folder(pObject, pForm)
15791 15792
15793 -def fl_set_folder_byname(pObject, name):
15794 """ fl_set_folder_byname(pObject, name) 15795 """ 15796 15797 _fl_set_folder_byname = cfuncproto( 15798 load_so_libforms(), "fl_set_folder_byname", 15799 None, [cty.POINTER(FL_OBJECT), STRING], 15800 """void fl_set_folder_byname(FL_OBJECT * ob, const char * name) 15801 """) 15802 sname = convert_to_string(name) 15803 keep_elem_refs(pObject, name, sname) 15804 _fl_set_folder_byname(pObject, name)
15805 15806
15807 -def fl_set_folder_bynumber(pObject, num):
15808 """ fl_set_folder_bynumber(pObject, num) 15809 """ 15810 15811 _fl_set_folder_bynumber = cfuncproto( 15812 load_so_libforms(), "fl_set_folder_bynumber", 15813 None, [cty.POINTER(FL_OBJECT), cty.c_int], 15814 """void fl_set_folder_bynumber(FL_OBJECT * ob, int num) 15815 """) 15816 inum = convert_to_int(num) 15817 keep_elem_refs(pObject, num, inum) 15818 _fl_set_folder_bynumber(pObject, inum)
15819 15820
15821 -def fl_get_folder(pObject):
15822 """ 15823 fl_get_folder(pObject) -> pForm 15824 15825 @param pObject : pointer to object 15826 """ 15827 15828 _fl_get_folder = cfuncproto( 15829 load_so_libforms(), "fl_get_folder", 15830 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 15831 """FL_FORM * fl_get_folder(FL_OBJECT * ob) 15832 """) 15833 keep_elem_refs(pObject) 15834 retval = _fl_get_folder(pObject) 15835 return retval
15836 15837
15838 -def fl_get_folder_number(pObject):
15839 """ 15840 fl_get_folder_number(pObject) -> folder num. 15841 15842 @param pObject : pointer to object 15843 """ 15844 15845 _fl_get_folder_number = cfuncproto( 15846 load_so_libforms(), "fl_get_folder_number", 15847 cty.c_int, [cty.POINTER(FL_OBJECT)], 15848 """int fl_get_folder_number(FL_OBJECT * ob) 15849 """) 15850 keep_elem_refs(pObject) 15851 retval = _fl_get_folder_number(pObject) 15852 return retval
15853 15854
15855 -def fl_get_folder_name(pObject):
15856 """ 15857 fl_get_folder_name(pObject) -> name string 15858 15859 @param pObject : pointer to object 15860 """ 15861 15862 _fl_get_folder_name = cfuncproto( 15863 load_so_libforms(), "fl_get_folder_name", 15864 STRING, [cty.POINTER(FL_OBJECT)], 15865 """const char * fl_get_folder_name(FL_OBJECT * ob) 15866 """) 15867 keep_elem_refs(pObject) 15868 retval = _fl_get_folder_name(pObject) 15869 return retval
15870 15871
15872 -def fl_get_tabfolder_numfolders(pObject):
15873 """ 15874 fl_get_tabfolder_numfolders(pObject) -> num. 15875 15876 @param pObject : pointer to object 15877 """ 15878 15879 _fl_get_tabfolder_numfolders = cfuncproto( 15880 load_so_libforms(), "fl_get_tabfolder_numfolders", 15881 cty.c_int, [cty.POINTER(FL_OBJECT)], 15882 """int fl_get_tabfolder_numfolders(FL_OBJECT * ob) 15883 """) 15884 keep_elem_refs(pObject) 15885 retval = _fl_get_tabfolder_numfolders(pObject) 15886 return retval
15887 15888
15889 -def fl_get_active_folder(pObject):
15890 """ 15891 fl_get_active_folder(pObject) -> pForm 15892 15893 @param pObject : pointer to object 15894 """ 15895 15896 _fl_get_active_folder = cfuncproto( 15897 load_so_libforms(), "fl_get_active_folder", 15898 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 15899 """FL_FORM * fl_get_active_folder(FL_OBJECT * ob) 15900 """) 15901 keep_elem_refs(pObject) 15902 retval = _fl_get_active_folder(pObject) 15903 return retval
15904 15905
15906 -def fl_get_active_folder_number(pObject):
15907 """ 15908 fl_get_active_folder_number(pObject) -> num. 15909 15910 @param pObject : pointer to object 15911 """ 15912 15913 _fl_get_active_folder_number = cfuncproto( 15914 load_so_libforms(), "fl_get_active_folder_number", 15915 cty.c_int, [cty.POINTER(FL_OBJECT)], 15916 """int fl_get_active_folder_number(FL_OBJECT * ob) 15917 """) 15918 keep_elem_refs(pObject) 15919 retval = _fl_get_active_folder_number(pObject) 15920 return retval
15921 15922
15923 -def fl_get_active_folder_name(pObject):
15924 """ 15925 fl_get_active_folder_name(pObject) -> name string 15926 15927 @param pObject : pointer to object 15928 """ 15929 15930 _fl_get_active_folder_name = cfuncproto( 15931 load_so_libforms(), "fl_get_active_folder_name", 15932 STRING, [cty.POINTER(FL_OBJECT)], 15933 """const char * fl_get_active_folder_name(FL_OBJECT * ob) 15934 """) 15935 keep_elem_refs(pObject) 15936 retval = _fl_get_active_folder_name(pObject) 15937 return retval
15938 15939 15940 #def fl_get_folder_area(pObject, x, y, w, h) *API change*
15941 -def fl_get_folder_area(pObject):
15942 """ 15943 fl_get_folder_area(pObject) -> x, y, w, h 15944 15945 @param pObject : pointer to object 15946 """ 15947 15948 _fl_get_folder_area = cfuncproto( 15949 load_so_libforms(), "fl_get_folder_area", 15950 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 15951 cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 15952 cty.POINTER(FL_Coord)], 15953 """void fl_get_folder_area(FL_OBJECT * ob, FL_Coord * x, 15954 FL_Coord * y, FL_Coord * w, FL_Coord * h) 15955 """) 15956 x, px = make_int_and_pointer() 15957 y, py = make_int_and_pointer() 15958 w, pw = make_int_and_pointer() 15959 h, ph = make_int_and_pointer() 15960 keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 15961 _fl_get_folder_area(pObject, px, py, pw, ph) 15962 return x, y, w, h
15963 15964
15965 -def fl_replace_folder_bynumber(pObject, num, pForm):
15966 """ 15967 fl_replace_folder_bynumber(pObject, num, pForm) 15968 15969 @param pObject : pointer to object 15970 """ 15971 15972 _fl_replace_folder_bynumber = cfuncproto( 15973 load_so_libforms(), "fl_replace_folder_bynumber", 15974 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(FL_FORM)], 15975 """void fl_replace_folder_bynumber(FL_OBJECT * ob, int num, 15976 FL_FORM * form) 15977 """) 15978 inum = convert_to_int(num) 15979 keep_elem_refs(pObject, num, pForm, inum) 15980 _fl_replace_folder_bynumber(pObject, inum, pForm)
15981 15982
15983 -def fl_set_tabfolder_autofit(pObject, num):
15984 """ 15985 fl_set_tabfolder_autofit(pObject, num) -> num. 15986 15987 @param pObject : pointer to object 15988 """ 15989 15990 _fl_set_tabfolder_autofit = cfuncproto( 15991 load_so_libforms(), "fl_set_tabfolder_autofit", 15992 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 15993 """int fl_set_tabfolder_autofit(FL_OBJECT * ob, int y) 15994 """) 15995 inum = convert_to_int(num) 15996 keep_elem_refs(pObject, num, inum) 15997 retval = _fl_set_tabfolder_autofit(pObject, inum) 15998 return retval
15999 16000
16001 -def fl_set_default_tabfolder_corner(npixels):
16002 """ 16003 fl_set_default_tabfolder_corner(npixels) -> old pixels num. 16004 16005 Adjusts the corner pixels, changing appearance of the tabs. 16006 16007 @param npixels : number of corner pixels (default 3) 16008 """ 16009 16010 _fl_set_default_tabfolder_corner = cfuncproto( 16011 load_so_libforms(), "fl_set_default_tabfolder_corner", 16012 cty.c_int, [cty.c_int], 16013 """int fl_set_default_tabfolder_corner(int n): 16014 """) 16015 ipixels = convert_to_int(npixels) 16016 keep_elem_refs(npixels, ipixels) 16017 retval = _fl_set_default_tabfolder_corner(ipixels) 16018 return retval
16019 16020
16021 -def fl_set_tabfolder_offset(pObject, offset):
16022 """ 16023 fl_set_tabfolder_offset(pObject, offset) -> num. 16024 16025 @param pObject : pointer to tabfolder object 16026 """ 16027 16028 _fl_set_tabfolder_offset = cfuncproto( 16029 load_so_libforms(), "fl_set_tabfolder_offset", 16030 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 16031 """int fl_set_tabfolder_offset(FL_OBJECT * ob, int offset) 16032 """) 16033 ioffset = convert_to_int(offset) 16034 keep_elem_refs(pObject, offset, ioffset) 16035 retval = _fl_set_tabfolder_offset(pObject, ioffset) 16036 return retval
16037 16038 16039 16040 ################### 16041 # forms.h (text.h) 16042 ################### 16043
16044 -def fl_create_text(texttype, x, y, w, h, label):
16045 """ 16046 fl_create_text(texttype, x, y, w, h, label) -> pObject 16047 """ 16048 16049 _fl_create_text = cfuncproto( 16050 load_so_libforms(), "fl_create_text", 16051 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16052 FL_Coord, STRING], 16053 """FL_OBJECT * fl_create_text(int type, FL_Coord x, FL_Coord y, 16054 FL_Coord w, FL_Coord h, const char * label) 16055 """) 16056 check_admitted_listvalues(texttype, TEXTTYPE_list) 16057 itexttype = convert_to_int(texttype) 16058 ix = convert_to_FL_Coord(x) 16059 iy = convert_to_FL_Coord(y) 16060 iw = convert_to_FL_Coord(w) 16061 ih = convert_to_FL_Coord(h) 16062 slabel = convert_to_string(label) 16063 keep_elem_refs(texttype, x, y, w, h, label, itexttype, ix, iy, 16064 iw, ih, slabel) 16065 retval = _fl_create_text(itexttype, ix, iy, iw, ih, slabel) 16066 return retval
16067 16068
16069 -def fl_add_text(texttype, x, y, w, h, label):
16070 """ 16071 fl_add_text(texttype, x, y, w, h, label) -> pObject 16072 """ 16073 16074 _fl_add_text = cfuncproto( 16075 load_so_libforms(), "fl_add_text", 16076 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16077 FL_Coord, STRING], 16078 """FL_OBJECT * fl_add_text(int type, FL_Coord x, FL_Coord y, 16079 FL_Coord w, FL_Coord h, const char * label) 16080 """) 16081 check_admitted_listvalues(texttype, TEXTTYPE_list) 16082 itexttype = convert_to_int(texttype) 16083 ix = convert_to_FL_Coord(x) 16084 iy = convert_to_FL_Coord(y) 16085 iw = convert_to_FL_Coord(w) 16086 ih = convert_to_FL_Coord(h) 16087 slabel = convert_to_string(label) 16088 keep_elem_refs(texttype, x, y, w, h, label, itexttype, ix, iy, 16089 iw, ih, slabel) 16090 retval = _fl_add_text(itexttype, ix, iy, iw, ih, slabel) 16091 return retval
16092 16093 16094 16095 ######################### 16096 # forms.h (thumbwheel.h) 16097 ######################### 16098
16099 -def fl_get_thumbwheel_value(pObject):
16100 """ 16101 fl_get_thumbwheel_value(pObject) -> num. 16102 16103 @param pObject : pointer to object 16104 """ 16105 16106 _fl_get_thumbwheel_value = cfuncproto( 16107 load_so_libforms(), "fl_get_thumbwheel_value", 16108 cty.c_double, [cty.POINTER(FL_OBJECT)], 16109 """double fl_get_thumbwheel_value(FL_OBJECT * ob) 16110 """) 16111 keep_elem_refs(pObject) 16112 retval = _fl_get_thumbwheel_value(pObject) 16113 return retval
16114 16115
16116 -def fl_set_thumbwheel_value(pObject, value):
16117 """ 16118 fl_set_thumbwheel_value(pObject, value) 16119 16120 @param pObject : pointer to object 16121 """ 16122 16123 _fl_set_thumbwheel_value = cfuncproto( 16124 load_so_libforms(), "fl_set_thumbwheel_value", 16125 cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 16126 """double fl_set_thumbwheel_value(FL_OBJECT * ob, double value) 16127 """) 16128 fvalue = convert_to_double(value) 16129 keep_elem_refs(pObject, value, fvalue) 16130 retval = _fl_set_thumbwheel_value(pObject, fvalue) 16131 return retval
16132 16133
16134 -def fl_get_thumbwheel_step(pObject):
16135 """ 16136 fl_get_thumbwheel_step(pObject) -> num. 16137 16138 @param pObject : pointer to object 16139 """ 16140 16141 _fl_get_thumbwheel_step = cfuncproto( 16142 load_so_libforms(), "fl_get_thumbwheel_step", 16143 cty.c_double, [cty.POINTER(FL_OBJECT)], 16144 """double fl_get_thumbwheel_step(FL_OBJECT * ob) 16145 """) 16146 keep_elem_refs(pObject) 16147 retval = _fl_get_thumbwheel_step(pObject) 16148 return retval
16149 16150
16151 -def fl_set_thumbwheel_step(pObject, step):
16152 """ 16153 fl_set_thumbwheel_step(pObject, step) -> num. 16154 16155 @param pObject : pointer to object 16156 """ 16157 16158 _fl_set_thumbwheel_step = cfuncproto( 16159 load_so_libforms(), "fl_set_thumbwheel_step", 16160 cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 16161 """double fl_set_thumbwheel_step(FL_OBJECT * ob, double step) 16162 """) 16163 fstep = convert_to_double(step) 16164 keep_elem_refs(pObject, step, fstep) 16165 retval = _fl_set_thumbwheel_step(pObject, fstep) 16166 return retval
16167 16168
16169 -def fl_set_thumbwheel_return(pObject, when):
16170 """ 16171 fl_set_thumbwheel_return(pObject, when) -> num. 16172 16173 @param pObject : pointer to object 16174 """ 16175 16176 _fl_set_thumbwheel_return = cfuncproto( 16177 load_so_libforms(), "fl_set_thumbwheel_return", 16178 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 16179 """int fl_set_thumbwheel_return(FL_OBJECT * ob, int how) 16180 """) 16181 check_admitted_listvalues(when, RETURN_list) 16182 iwhen = convert_to_int(when) 16183 keep_elem_refs(pObject, when, iwhen) 16184 retval = _fl_set_thumbwheel_return(pObject, when) 16185 return retval
16186 16187
16188 -def fl_set_thumbwheel_crossover(pObject, flag):
16189 """ 16190 fl_set_thumbwheel_crossover(pObject, flag) -> num. 16191 16192 @param pObject : pointer to object 16193 """ 16194 16195 _fl_set_thumbwheel_crossover = cfuncproto( 16196 load_so_libforms(), "fl_set_thumbwheel_crossover", 16197 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 16198 """int fl_set_thumbwheel_crossover(FL_OBJECT * ob, int flag) 16199 """) 16200 iflag = convert_to_int(flag) 16201 keep_elem_refs(pObject, flag, iflag) 16202 retval = _fl_set_thumbwheel_crossover(pObject, iflag) 16203 return retval
16204 16205
16206 -def fl_set_thumbwheel_bounds(pObject, minbound, maxbound):
16207 """ 16208 fl_set_thumbwheel_bounds(pObject, minbound, maxbound) 16209 16210 @param pObject : pointer to object 16211 """ 16212 16213 _fl_set_thumbwheel_bounds = cfuncproto( 16214 load_so_libforms(), "fl_set_thumbwheel_bounds", 16215 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 16216 """void fl_set_thumbwheel_bounds(FL_OBJECT * ob, double min, 16217 double max) 16218 """) 16219 fminbound = convert_to_double(minbound) 16220 fmaxbound = convert_to_double(maxbound) 16221 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 16222 _fl_set_thumbwheel_bounds(pObject, fminbound, fmaxbound)
16223 16224 16225 #def fl_get_thumbwheel_bounds(pObject, minbound, maxbound) *API change*
16226 -def fl_get_thumbwheel_bounds(pObject):
16227 """ 16228 fl_get_thumbwheel_bounds(pObject) -> minbound, maxbound 16229 16230 @param pObject : pointer to thumbwheel object 16231 """ 16232 16233 _fl_get_thumbwheel_bounds = cfuncproto( 16234 load_so_libforms(), "fl_get_thumbwheel_bounds", 16235 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 16236 cty.POINTER(cty.c_double)], 16237 """void fl_get_thumbwheel_bounds(FL_OBJECT * ob, double * min, 16238 double * max) 16239 """) 16240 minbound, pminbound = make_double_and_pointer() 16241 maxbound, pmaxbound = make_double_and_pointer() 16242 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 16243 _fl_get_thumbwheel_bounds(pObject, pminbound, pmaxbound) 16244 return minbound, maxbound
16245 16246
16247 -def fl_create_thumbwheel(wheeltype, x, y, w, h, label):
16248 """ 16249 fl_create_thumbwheel(wheeltype, x, y, w, h, label) -> pObject 16250 """ 16251 16252 _fl_create_thumbwheel = cfuncproto( 16253 load_so_libforms(), "fl_create_thumbwheel", 16254 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16255 FL_Coord, STRING], 16256 """FL_OBJECT * fl_create_thumbwheel(int type, FL_Coord x, 16257 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 16258 """) 16259 check_admitted_listvalues(wheeltype, THUMBWHEELTYPE_list) 16260 iwheeltype = convert_to_int(wheeltype) 16261 ix = convert_to_FL_Coord(x) 16262 iy = convert_to_FL_Coord(y) 16263 iw = convert_to_FL_Coord(w) 16264 ih = convert_to_FL_Coord(h) 16265 slabel = convert_to_string(label) 16266 keep_elem_refs(wheeltype, x, y, w, h, label, iwheeltype, ix, iy, 16267 iw, ih, slabel) 16268 retval = _fl_create_thumbwheel(iwheeltype, ix, iy, iw, ih, slabel) 16269 return retval
16270 16271
16272 -def fl_add_thumbwheel(wheeltype, x, y, w, h, label):
16273 """ 16274 fl_add_thumbwheel(wheeltype, x, y, w, h, label) -> pObject 16275 """ 16276 16277 _fl_add_thumbwheel = cfuncproto( 16278 load_so_libforms(), "fl_add_thumbwheel", 16279 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16280 FL_Coord, STRING], 16281 """FL_OBJECT * fl_add_thumbwheel(int type, FL_Coord x, FL_Coord y, 16282 FL_Coord w, FL_Coord h, const char * label) 16283 """) 16284 check_admitted_listvalues(wheeltype, THUMBWHEELTYPE_list) 16285 iwheeltype = convert_to_int(wheeltype) 16286 ix = convert_to_FL_Coord(x) 16287 iy = convert_to_FL_Coord(y) 16288 iw = convert_to_FL_Coord(w) 16289 ih = convert_to_FL_Coord(h) 16290 slabel = convert_to_string(label) 16291 keep_elem_refs(wheeltype, x, y, w, h, label, iwheeltype, ix, iy, 16292 iw, ih, slabel) 16293 retval = _fl_add_thumbwheel(iwheeltype, ix, iy, iw, ih, slabel) 16294 return retval
16295 16296 16297 16298 ###################### 16299 # forms.h (timer.h) 16300 # Object Class: Timer 16301 ###################### 16302 16303 # Routines 16304
16305 -def fl_create_timer(timertype, x, y, w, h, label):
16306 """ 16307 fl_create_timer(timertype, x, y, w, h, label) -> pObject 16308 """ 16309 16310 _fl_create_timer = cfuncproto( 16311 load_so_libforms(), "fl_create_timer", 16312 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16313 FL_Coord, STRING], 16314 """FL_OBJECT * fl_create_timer(int type, FL_Coord x, FL_Coord y, 16315 FL_Coord w, FL_Coord h, const char * label) 16316 """) 16317 check_admitted_listvalues(timertype, TIMERTYPE_list) 16318 itimertype = convert_to_int(timertype) 16319 ix = convert_to_FL_Coord(x) 16320 iy = convert_to_FL_Coord(y) 16321 iw = convert_to_FL_Coord(w) 16322 ih = convert_to_FL_Coord(h) 16323 slabel = convert_to_string(label) 16324 keep_elem_refs(timertype, x, y, w, h, label, itimertype, ix, iy, 16325 iw, ih, slabel) 16326 retval = _fl_create_timer(itimertype, ix, iy, iw, ih, slabel) 16327 return retval
16328 16329
16330 -def fl_add_timer(timertype, x, y, w, h, label):
16331 """ 16332 fl_add_timer(timertype, x, y, w, h, label) -> pObject 16333 """ 16334 16335 _fl_add_timer = cfuncproto( 16336 load_so_libforms(), "fl_add_timer", 16337 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16338 FL_Coord, STRING], 16339 """FL_OBJECT * fl_add_timer(int type, FL_Coord x, FL_Coord y, 16340 FL_Coord w, FL_Coord h, const char * label) 16341 """) 16342 check_admitted_listvalues(timertype, TIMERTYPE_list) 16343 itimertype = convert_to_int(timertype) 16344 ix = convert_to_FL_Coord(x) 16345 iy = convert_to_FL_Coord(y) 16346 iw = convert_to_FL_Coord(w) 16347 ih = convert_to_FL_Coord(h) 16348 slabel = convert_to_string(label) 16349 keep_elem_refs(timertype, x, y, w, h, label, itimertype, ix, iy, 16350 iw, ih, slabel) 16351 retval = _fl_add_timer(itimertype, ix, iy, iw, ih, slabel) 16352 return retval
16353 16354
16355 -def fl_set_timer(pObject, total):
16356 """ 16357 fl_set_timer(pObject, total) 16358 16359 @param pObject : pointer to object 16360 """ 16361 16362 _fl_set_timer = cfuncproto( 16363 load_so_libforms(), "fl_set_timer", 16364 None, [cty.POINTER(FL_OBJECT), cty.c_double], 16365 """void fl_set_timer(FL_OBJECT * ob, double total) 16366 """) 16367 ftotal = convert_to_double(total) 16368 keep_elem_refs(pObject, total, ftotal) 16369 _fl_set_timer(pObject, ftotal)
16370 16371
16372 -def fl_get_timer(pObject):
16373 """ 16374 fl_get_timer(pObject) -> num. 16375 16376 @param pObject : pointer to object 16377 """ 16378 16379 _fl_get_timer = cfuncproto( 16380 load_so_libforms(), "fl_get_timer", 16381 cty.c_double, [cty.POINTER(FL_OBJECT)], 16382 """double fl_get_timer(FL_OBJECT * ob) 16383 """) 16384 keep_elem_refs(pObject) 16385 retval = _fl_get_timer(pObject) 16386 return retval
16387 16388
16389 -def fl_set_timer_countup(pObject, yes):
16390 """ 16391 fl_set_timer_countup(pObject, yes) 16392 16393 @param pObject : pointer to object 16394 """ 16395 16396 _fl_set_timer_countup = cfuncproto( 16397 load_so_libforms(), "fl_set_timer_countup", 16398 None, [cty.POINTER(FL_OBJECT), cty.c_int], 16399 """void fl_set_timer_countup(FL_OBJECT * ob, int yes) 16400 """) 16401 iyes = convert_to_int(yes) 16402 keep_elem_refs(pObject, yes, iyes) 16403 _fl_set_timer_countup(pObject, iyes)
16404 16405 16406 FL_TIMER_FILTER = cty.CFUNCTYPE(STRING, cty.POINTER(FL_OBJECT), cty.c_double) 16407
16408 -def fl_set_timer_filter(pObject, py_TimerFilter):
16409 """ 16410 fl_set_timer_filter(pObject, py_TimerFilter) -> timer_filter func. 16411 16412 @param pObject : pointer to object 16413 @param py_TimerFilter : python function, fn(pObject, valfloat) -> 16414 string 16415 """ 16416 16417 _fl_set_timer_filter = cfuncproto( 16418 load_so_libforms(), "fl_set_timer_filter", 16419 FL_TIMER_FILTER, [cty.POINTER(FL_OBJECT), FL_TIMER_FILTER], 16420 """FL_TIMER_FILTER fl_set_timer_filter(FL_OBJECT * ob, 16421 FL_TIMER_FILTER filter) 16422 """) 16423 c_TimerFilter = FL_TIMER_FILTER(py_TimerFilter) 16424 keep_cfunc_refs(c_TimerFilter, py_TimerFilter) 16425 keep_elem_refs(pObject) 16426 retval = _fl_set_timer_filter(pObject, c_TimerFilter) 16427 return retval
16428 16429
16430 -def fl_suspend_timer(pObject):
16431 """ 16432 fl_suspend_timer(pObject) 16433 16434 @param pObject : pointer to object 16435 """ 16436 16437 _fl_suspend_timer = cfuncproto( 16438 load_so_libforms(), "fl_suspend_timer", 16439 None, [cty.POINTER(FL_OBJECT)], 16440 """void fl_suspend_timer(FL_OBJECT * ob) 16441 """) 16442 keep_elem_refs(pObject) 16443 _fl_suspend_timer(pObject)
16444 16445
16446 -def fl_resume_timer(pObject):
16447 """ 16448 fl_resume_timer(pObject) 16449 16450 Resume timer previously paused. 16451 16452 @param pObject : pointer to timer object 16453 """ 16454 16455 _fl_resume_timer = cfuncproto( 16456 load_so_libforms(), "fl_resume_timer", 16457 None, [cty.POINTER(FL_OBJECT)], 16458 """void fl_resume_timer(FL_OBJECT * ob) 16459 """) 16460 keep_elem_refs(pObject) 16461 _fl_resume_timer(pObject)
16462 16463 16464 16465 ############################### 16466 # forms.h (xpopup.h) 16467 # Prototypes for xpop-up menus 16468 ############################### 16469
16470 -def fl_setpup_entries(popupid, pPopupEntry):
16471 """ 16472 fl_setpup_entries(popupid, pPopupEntry) -> num. 16473 """ 16474 16475 _fl_setpup_entries = cfuncproto( 16476 load_so_libforms(), "fl_setpup_entries", 16477 cty.c_int, [cty.c_int, cty.POINTER(FL_PUP_ENTRY)], 16478 """int fl_setpup_entries(int nm, FL_PUP_ENTRY * entries) 16479 """) 16480 ipopupid = convert_to_int(popupid) 16481 keep_elem_refs(popupid, pPopupEntry, ipopupid) 16482 retval = _fl_setpup_entries(ipopupid, pPopupEntry) 16483 return retval
16484 16485
16486 -def fl_newpup(win):
16487 """ 16488 fl_newpup(win) -> num. 16489 """ 16490 16491 _fl_newpup = cfuncproto( 16492 load_so_libforms(), "fl_newpup", 16493 cty.c_int, [Window], 16494 """int fl_newpup(Window win) 16495 """) 16496 ulwin = convert_to_Window(win) 16497 keep_elem_refs(win, ulwin) 16498 retval = _fl_newpup(ulwin) 16499 return retval
16500 16501
16502 -def fl_defpup(win, pupstr):
16503 """ 16504 fl_defpup(win, pupstr) -> num. 16505 """ 16506 16507 _fl_defpup = cfuncproto( 16508 load_so_libforms(), "fl_defpup", 16509 cty.c_int, [Window, STRING], 16510 """int fl_defpup(Window win, const char * str): 16511 """) 16512 ulwin = convert_to_Window(win) 16513 spupstr = convert_to_string(pupstr) 16514 keep_elem_refs(win, pupstr, ulwin, spupstr) 16515 retval = _fl_defpup(ulwin, spupstr) 16516 return retval
16517 16518
16519 -def fl_addtopup(popupid, pupstr):
16520 """ 16521 fl_addtopup(popupid, pupstr) -> num. 16522 """ 16523 16524 _fl_addtopup = cfuncproto( 16525 load_so_libforms(), "fl_addtopup", 16526 cty.c_int, [cty.c_int, STRING], 16527 """int fl_addtopup(int n, const char * str) 16528 """) 16529 ipopupid = convert_to_int(popupid) 16530 spupstr = convert_to_string(pupstr) 16531 keep_elem_refs(popupid, pupstr, ipopupid, spupstr) 16532 retval = _fl_addtopup(ipopupid, spupstr) 16533 return retval
16534 16535
16536 -def fl_setpup_mode(popupid, itemval, mode):
16537 """ 16538 fl_setpup_mode(popupid, itemval, mode) -> num. 16539 """ 16540 16541 _fl_setpup_mode = cfuncproto( 16542 load_so_libforms(), "fl_setpup_mode", 16543 cty.c_int, [cty.c_int, cty.c_int, cty.c_uint], 16544 """int fl_setpup_mode(int nm, int ni, unsigned int mode) 16545 """) 16546 ipopupid = convert_to_int(popupid) 16547 iitemval = convert_to_int(itemval) 16548 uimode = convert_to_uint(mode) 16549 keep_elem_refs(popupid, itemval, mode, ipopupid, iitemval, uimode) 16550 retval = _fl_setpup_mode(ipopupid, iitemval, uimode) 16551 return retval
16552 16553
16554 -def fl_freepup(popupid):
16555 """ 16556 fl_freepup(popupid) 16557 """ 16558 16559 _fl_freepup = cfuncproto( 16560 load_so_libforms(), "fl_freepup", 16561 None, [cty.c_int], 16562 """void fl_freepup(int n) 16563 """) 16564 ipopupid = convert_to_int(popupid) 16565 keep_elem_refs(popupid, ipopupid) 16566 _fl_freepup(ipopupid)
16567 16568
16569 -def fl_dopup(popupid):
16570 """ 16571 fl_dopup(popupid) -> num. 16572 """ 16573 16574 _fl_dopup = cfuncproto( 16575 load_so_libforms(), "fl_dopup", 16576 cty.c_int, [cty.c_int], 16577 """int fl_dopup(int n) 16578 """) 16579 ipopupid = convert_to_int(popupid) 16580 keep_elem_refs(popupid, ipopupid) 16581 retval = _fl_dopup(ipopupid) 16582 return retval
16583 16584
16585 -def fl_setpup_default_cursor(cursor):
16586 """ 16587 fl_setpup_default_cursor(cursor) -> cursor 16588 """ 16589 16590 _fl_setpup_default_cursor = cfuncproto( 16591 load_so_libforms(), "fl_setpup_default_cursor", 16592 Cursor, [cty.c_int], 16593 """Cursor fl_setpup_default_cursor(int cursor): 16594 """) 16595 icursor = convert_to_int(cursor) 16596 keep_elem_refs(cursor, icursor) 16597 retval = _fl_setpup_default_cursor(icursor) 16598 return retval
16599 16600
16601 -def fl_setpup_default_color(fgcolr, bgcolr):
16602 """ 16603 fl_setpup_default_color(fgcolr, bgcolr) 16604 """ 16605 16606 _fl_setpup_default_color = cfuncproto( 16607 load_so_libforms(), "fl_setpup_default_color", 16608 None, [FL_COLOR, FL_COLOR], 16609 """void fl_setpup_default_color(FL_COLOR fg, FL_COLOR bg) 16610 """) 16611 ulfgcolr = convert_to_FL_COLOR(fgcolr) 16612 ulbgcolr = convert_to_FL_COLOR(bgcolr) 16613 keep_elem_refs(fgcolr, bgcolr, ulfgcolr, ulbgcolr) 16614 _fl_setpup_default_color(ulfgcolr, ulbgcolr)
16615 16616
16617 -def fl_setpup_default_pup_checked_color(colr):
16618 """ 16619 fl_setpup_default_pup_checked_color(colr): 16620 """ 16621 16622 _fl_setpup_default_pup_checked_color = cfuncproto( 16623 load_so_libforms(), "fl_setpup_default_pup_checked_color", 16624 None, [FL_COLOR], 16625 """void fl_setpup_default_pup_checked_color(FL_COLOR col) 16626 """) 16627 ulcolr = convert_to_FL_COLOR(colr) 16628 keep_elem_refs(colr, ulcolr) 16629 _fl_setpup_default_pup_checked_color(ulcolr)
16630 16631
16632 -def fl_setpup_default_fontsize(size):
16633 """ 16634 fl_setpup_default_fontsize(size) -> num. 16635 """ 16636 16637 _fl_setpup_default_fontsize = cfuncproto( 16638 load_so_libforms(), "fl_setpup_default_fontsize", 16639 cty.c_int, [cty.c_int], 16640 """int fl_setpup_default_fontsize(int size) DEPRECATED? 16641 """) 16642 isize = convert_to_int(size) 16643 keep_elem_refs(size, isize) 16644 retval = _fl_setpup_default_fontsize(isize) 16645 return retval
16646 16647
16648 -def fl_setpup_default_fontstyle(style):
16649 """ 16650 fl_setpup_default_fontstyle(style) -> num. 16651 """ 16652 16653 _fl_setpup_default_fontstyle = cfuncproto( 16654 load_so_libforms(), "fl_setpup_default_fontstyle", 16655 cty.c_int, [cty.c_int], 16656 """int fl_setpup_default_fontstyle(int style) 16657 """) 16658 istyle = convert_to_int(style) 16659 keep_elem_refs(style, istyle) 16660 retval = _fl_setpup_default_fontstyle(istyle) 16661 return retval
16662 16663 16664 fl_setpup_fontsize = fl_setpup_default_fontsize 16665 fl_setpup_fontstyle = fl_setpup_default_fontstyle 16666 fl_setpup_color = fl_setpup_default_color 16667 fl_setpup_default_checkcolor = fl_setpup_default_pup_checked_color 16668 fl_setpup_checkcolor = fl_setpup_default_pup_checked_color 16669 16670
16671 -def fl_setpup_default_bw(bw):
16672 """ 16673 fl_setpup_default_bw(bw) -> num. 16674 """ 16675 16676 _fl_setpup_default_bw = cfuncproto( 16677 load_so_libforms(), "fl_setpup_default_bw", 16678 cty.c_int, [cty.c_int], 16679 """int fl_setpup_default_bw(int bw): 16680 """) 16681 ibw = convert_to_int(bw) 16682 keep_elem_refs(bw, ibw) 16683 retval = _fl_setpup_default_bw(ibw) 16684 return retval
16685 16686
16687 -def fl_setpup_shortcut(popupid, itemval, hotkeystxt):
16688 """ 16689 fl_setpup_shortcut(popupid, itemval, hotkeystxt) 16690 """ 16691 16692 _fl_setpup_shortcut = cfuncproto( 16693 load_so_libforms(), "fl_setpup_shortcut", 16694 None, [cty.c_int, cty.c_int, STRING], 16695 """void fl_setpup_shortcut(int nm, int ni, const char * sc) 16696 """) 16697 ipopupid = convert_to_int(popupid) 16698 iitemval = convert_to_int(itemval) 16699 shotkeystxt = convert_to_string(hotkeystxt) 16700 keep_elem_refs(popupid, itemval, hotkeystxt, ipopupid, iitemval, \ 16701 shotkeystxt) 16702 _fl_setpup_shortcut(ipopupid, iitemval, shotkeystxt)
16703 16704
16705 -def fl_setpup_position(x, y):
16706 """ 16707 fl_setpup_position(x, y) 16708 """ 16709 16710 _fl_setpup_position = cfuncproto( 16711 load_so_libforms(), "fl_setpup_position", 16712 None, [cty.c_int, cty.c_int], 16713 """void fl_setpup_position(int x, int y) 16714 """) 16715 ix = convert_to_int(x) 16716 iy = convert_to_int(y) 16717 keep_elem_refs(x, y, ix, iy) 16718 _fl_setpup_position(ix, iy)
16719 16720
16721 -def fl_setpup_selection(popupid, itemval):
16722 """ 16723 fl_setpup_selection(popupid, itemval) 16724 """ 16725 16726 _fl_setpup_selection = cfuncproto( 16727 load_so_libforms(), "fl_setpup_selection", 16728 None, [cty.c_int, cty.c_int], 16729 """void fl_setpup_selection(int nm, int ni) 16730 """) 16731 ipopupid = convert_to_int(popupid) 16732 iitemval = convert_to_int(itemval) 16733 keep_elem_refs(popupid, itemval, ipopupid, iitemval) 16734 _fl_setpup_selection(ipopupid, iitemval)
16735 16736
16737 -def fl_setpup_shadow(popupid, flag):
16738 """ 16739 fl_setpup_shadow(popupid, flag) 16740 """ 16741 16742 _fl_setpup_shadow = cfuncproto( 16743 load_so_libforms(), "fl_setpup_shadow", 16744 None, [cty.c_int, cty.c_int], 16745 """void fl_setpup_shadow(int n, int y) 16746 """) 16747 ipopupid = convert_to_int(popupid) 16748 iflag = convert_to_int(flag) 16749 keep_elem_refs(popupid, flag, ipopupid, iflag) 16750 _fl_setpup_shadow(ipopupid, iflag)
16751 16752
16753 -def fl_setpup_softedge(popupid, flag):
16754 """ 16755 fl_setpup_softedge(popupid, flag) 16756 """ 16757 16758 _fl_setpup_softedge = cfuncproto( 16759 load_so_libforms(), "fl_setpup_softedge", 16760 None, [cty.c_int, cty.c_int], 16761 """void fl_setpup_softedge(int n, int y) 16762 """) 16763 ipopupid = convert_to_int(popupid) 16764 iflag = convert_to_int(flag) 16765 keep_elem_refs(popupid, flag, ipopupid, iflag) 16766 _fl_setpup_softedge(ipopupid, iflag)
16767 16768
16769 -def fl_setpup_bw(popupid, bw):
16770 """ 16771 fl_setpup_bw(popupid, bw) 16772 """ 16773 16774 _fl_setpup_bw = cfuncproto( 16775 load_so_libforms(), "fl_setpup_bw", 16776 None, [cty.c_int, cty.c_int], 16777 """void fl_setpup_bw(int n, int bw) 16778 """) 16779 ipopupid = convert_to_int(popupid) 16780 ibw = convert_to_int(bw) 16781 keep_elem_refs(popupid, bw, ipopupid, ibw) 16782 _fl_setpup_bw(ipopupid, ibw)
16783 16784
16785 -def fl_setpup_title(popupid, title):
16786 """ 16787 fl_setpup_title(popupid, title) 16788 """ 16789 16790 _fl_setpup_title = cfuncproto( 16791 load_so_libforms(), "fl_setpup_title", 16792 None, [cty.c_int, STRING], 16793 """void fl_setpup_title(int nm, const char * title) 16794 """) 16795 ipopupid = convert_to_int(popupid) 16796 stitle = convert_to_string(title) 16797 keep_elem_refs(popupid, title, ipopupid, stitle) 16798 _fl_setpup_title(ipopupid, stitle)
16799 16800 16801 FL_PUP_ENTERCB = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 16802
16803 -def fl_setpup_entercb(popupid, py_PupEnterCb, data):
16804 """ 16805 fl_setpup_entercb(popupid, py_PupEnterCb, data) -> pup_entercb 16806 """ 16807 16808 _fl_setpup_entercb = cfuncproto( 16809 load_so_libforms(), "fl_setpup_entercb", 16810 FL_PUP_ENTERCB, [cty.c_int, FL_PUP_ENTERCB, cty.c_void_p], 16811 """FL_PUP_ENTERCB fl_setpup_entercb(int nm, FL_PUP_ENTERCB cb, 16812 void * data) 16813 """) 16814 ipopupid = convert_to_int(popupid) 16815 c_PupEnterCb = FL_PUP_ENTERCB(py_PupEnterCb) 16816 pdata = cty.cast(data, cty.c_void_p) 16817 keep_cfunc_refs(c_PupEnterCb, py_PupEnterCb) 16818 keep_elem_refs(popupid, data, ipopupid, pdata) 16819 retval = _fl_setpup_entercb(ipopupid, c_PupEnterCb, pdata) 16820 return retval
16821 16822 16823 FL_PUP_LEAVECB = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 16824
16825 -def fl_setpup_leavecb(popupid, py_LeaveCb, data):
16826 """ 16827 fl_setpup_leavecb(popupid, py_LeaveCb, data) -> pup_leavecb 16828 """ 16829 16830 _fl_setpup_leavecb = cfuncproto( 16831 load_so_libforms(), "fl_setpup_leavecb", 16832 FL_PUP_LEAVECB, [cty.c_int, FL_PUP_LEAVECB, cty.c_void_p], 16833 """FL_PUP_LEAVECB fl_setpup_leavecb(int nm, FL_PUP_LEAVECB cb, 16834 void * data) 16835 """) 16836 ipopupid = convert_to_int(popupid) 16837 c_LeaveCb = FL_PUP_LEAVECB(py_LeaveCb) 16838 pdata = cty.cast(data, cty.c_void_p) 16839 keep_cfunc_refs(c_LeaveCb, py_LeaveCb) 16840 keep_elem_refs(popupid, data, ipopupid, pdata) 16841 retval = _fl_setpup_leavecb(ipopupid, c_LeaveCb, pdata) 16842 return retval
16843 16844
16845 -def fl_setpup_pad(popupid, padw, padh):
16846 """ 16847 fl_setpup_pad(popupid, padw, padh) 16848 """ 16849 16850 _fl_setpup_pad = cfuncproto( 16851 load_so_libforms(), "fl_setpup_pad", 16852 None, [cty.c_int, cty.c_int, cty.c_int], 16853 """void fl_setpup_pad(int n, int padw, int padh) 16854 """) 16855 ipopupid = convert_to_int(popupid) 16856 ipadw = convert_to_int(padw) 16857 ipadh = convert_to_int(padh) 16858 keep_elem_refs(popupid, padw, padh, ipopupid, ipadw, ipadh) 16859 _fl_setpup_pad(ipopupid, ipadw, ipadh)
16860 16861
16862 -def fl_setpup_cursor(popupid, cursor):
16863 """ 16864 fl_setpup_cursor(popupid, cursor) -> cursor 16865 """ 16866 16867 _fl_setpup_cursor = cfuncproto( 16868 load_so_libforms(), "fl_setpup_cursor", 16869 Cursor, [cty.c_int, cty.c_int], 16870 """Cursor fl_setpup_cursor(int nm, int cursor) 16871 """) 16872 ipopupid = convert_to_int(popupid) 16873 icursor = convert_to_int(cursor) 16874 keep_elem_refs(popupid, cursor, ipopupid, icursor) 16875 retval = _fl_setpup_cursor(ipopupid, icursor) 16876 return retval
16877 16878
16879 -def fl_setpup_maxpup(newmaxnum):
16880 """ 16881 fl_setpup_maxpup(newmaxnum) -> num. 16882 """ 16883 16884 _fl_setpup_maxpup = cfuncproto( 16885 load_so_libforms(), "fl_setpup_maxpup", 16886 cty.c_int, [cty.c_int], 16887 """int fl_setpup_maxpup(int n) 16888 """) 16889 inewmaxnum = convert_to_int(newmaxnum) 16890 keep_elem_refs(newmaxnum, inewmaxnum) 16891 retval = _fl_setpup_maxpup(inewmaxnum) 16892 return retval
16893 16894
16895 -def fl_getpup_mode(popupid, itemval):
16896 """ 16897 fl_getpup_mode(popupid, itemval) -> num. 16898 """ 16899 16900 _fl_getpup_mode = cfuncproto( 16901 load_so_libforms(), "fl_getpup_mode", 16902 cty.c_uint, [cty.c_int, cty.c_int], 16903 """unsigned int fl_getpup_mode(int nm, int ni) 16904 """) 16905 ipopupid = convert_to_int(popupid) 16906 iitemval = convert_to_int(itemval) 16907 keep_elem_refs(popupid, itemval, ipopupid, iitemval) 16908 retval = _fl_getpup_mode(ipopupid, iitemval) 16909 return retval
16910 16911
16912 -def fl_getpup_text(popupid, itemval):
16913 """ 16914 fl_getpup_text(popupid, itemval) -> text string 16915 """ 16916 16917 _fl_getpup_text = cfuncproto( 16918 load_so_libforms(), "fl_getpup_text", 16919 STRING, [cty.c_int, cty.c_int], 16920 """const char * fl_getpup_text(int nm, int ni) 16921 """) 16922 ipopupid = convert_to_int(popupid) 16923 iitemval = convert_to_int(itemval) 16924 keep_elem_refs(popupid, itemval, ipopupid, iitemval) 16925 retval = _fl_getpup_text(ipopupid, iitemval) 16926 return retval
16927 16928
16929 -def fl_showpup(popupid):
16930 """ 16931 fl_showpup(popupid) 16932 """ 16933 16934 _fl_showpup = cfuncproto( 16935 load_so_libforms(), "fl_showpup", 16936 None, [cty.c_int], 16937 """void fl_showpup(int n) 16938 """) 16939 ipopupid = convert_to_int(popupid) 16940 keep_elem_refs(popupid, ipopupid) 16941 _fl_showpup(ipopupid)
16942 16943
16944 -def fl_hidepup(popupid):
16945 """ 16946 fl_hidepup(popupid) 16947 """ 16948 16949 _fl_hidepup = cfuncproto( 16950 load_so_libforms(), "fl_hidepup", 16951 None, [cty.c_int], 16952 """void fl_hidepup(int n) 16953 """) 16954 ipopupid = convert_to_int(popupid) 16955 keep_elem_refs(popupid, ipopupid) 16956 _fl_hidepup(ipopupid)
16957 16958
16959 -def fl_getpup_items(popupid):
16960 """ 16961 fl_getpup_items(popupid) -> num. 16962 """ 16963 16964 _fl_getpup_items = cfuncproto( 16965 load_so_libforms(), "fl_getpup_items", 16966 cty.c_int, [cty.c_int], 16967 """int fl_getpup_items(int n) 16968 """) 16969 ipopupid = convert_to_int(popupid) 16970 keep_elem_refs(popupid, ipopupid) 16971 retval = _fl_getpup_items(ipopupid) 16972 return retval
16973 16974
16975 -def fl_current_pup():
16976 """ 16977 fl_current_pup() -> num. 16978 """ 16979 16980 _fl_current_pup = cfuncproto( 16981 load_so_libforms(), "fl_current_pup", 16982 cty.c_int, [], 16983 """int fl_current_pup() 16984 """) 16985 retval = _fl_current_pup() 16986 return retval
16987 16988
16989 -def fl_setpup_itemcb(popupid, itemval, py_PupCb):
16990 """ 16991 fl_setpup_itemcb(popupid, itemval, py_PupCb) -> pup_cb 16992 """ 16993 16994 _fl_setpup_itemcb = cfuncproto( 16995 load_so_libforms(), "fl_setpup_itemcb", 16996 FL_PUP_CB, [cty.c_int, cty.c_int, FL_PUP_CB], 16997 """FL_PUP_CB fl_setpup_itemcb(int nm, int ni, FL_PUP_CB cb) 16998 """) 16999 ipopupid = convert_to_int(popupid) 17000 iitemval = convert_to_int(itemval) 17001 c_PupCb = FL_PUP_CB(py_PupCb) 17002 keep_cfunc_refs(c_PupCb, py_PupCb) 17003 keep_elem_refs(popupid, itemval, ipopupid, iitemval) 17004 retval = _fl_setpup_itemcb(ipopupid, iitemval, c_PupCb) 17005 return retval
17006 17007
17008 -def fl_setpup_menucb(popupid, py_PupCb):
17009 """ fl_setpup_menucb(popupid, py_PupCb) -> pup_cb func. 17010 """ 17011 17012 _fl_setpup_menucb = cfuncproto( 17013 load_so_libforms(), "fl_setpup_menucb", 17014 FL_PUP_CB, [cty.c_int, FL_PUP_CB], 17015 """FL_PUP_CB fl_setpup_menucb(int nm, FL_PUP_CB cb) 17016 """) 17017 ipopupid = convert_to_int(popupid) 17018 c_PupCb = FL_PUP_CB(py_PupCb) 17019 keep_cfunc_refs(c_PupCb, py_PupCb) 17020 keep_elem_refs(popupid, ipopupid) 17021 retval = _fl_setpup_menucb(ipopupid, c_PupCb) 17022 return retval
17023 17024
17025 -def fl_setpup_submenu(popupid, itemval, subpopupid):
17026 """ 17027 fl_setpup_submenu(popupid, itemval, subpopupid) 17028 """ 17029 17030 _fl_setpup_submenu = cfuncproto( 17031 load_so_libforms(), "fl_setpup_submenu", 17032 None, [cty.c_int, cty.c_int, cty.c_int], 17033 """void fl_setpup_submenu(int m, int i, int subm) 17034 """) 17035 ipopupid = convert_to_int(popupid) 17036 iitemval = convert_to_int(itemval) 17037 isubpopupid = convert_to_int(subpopupid) 17038 keep_elem_refs(popupid, itemval, subpopupid, ipopupid, iitemval, \ 17039 isubpopupid) 17040 _fl_setpup_submenu(ipopupid, iitemval, isubpopupid)
17041 17042 17043 fl_setpup = fl_setpup_mode 17044 17045 17046 # Others 17047
17048 -def fl_create_xyplot(plottype, x, y, w, h, label):
17049 """ 17050 fl_create_xyplot(plottype, x, y, w, h, label) -> pObject 17051 """ 17052 17053 _fl_create_xyplot = cfuncproto( 17054 load_so_libforms(), "fl_create_xyplot", 17055 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 17056 FL_Coord, STRING], 17057 """FL_OBJECT * fl_create_xyplot(int t, FL_Coord x, FL_Coord y, 17058 FL_Coord w, FL_Coord h, const char * label) 17059 """) 17060 check_admitted_listvalues(plottype, XYPLOTTYPE_list) 17061 iplottype = convert_to_int(plottype) 17062 ix = convert_to_FL_Coord(x) 17063 iy = convert_to_FL_Coord(y) 17064 iw = convert_to_FL_Coord(w) 17065 ih = convert_to_FL_Coord(h) 17066 slabel = convert_to_string(label) 17067 keep_elem_refs(plottype, x, y, w, h, label, iplottype, ix, iy, 17068 iw, ih, slabel) 17069 retval = _fl_create_xyplot(iplottype, ix, iy, iw, ih, slabel) 17070 return retval
17071 17072
17073 -def fl_add_xyplot(plottype, x, y, w, h, label):
17074 """ 17075 fl_add_xyplot(plottype, x, y, w, h, label) -> pObject 17076 """ 17077 17078 _fl_add_xyplot = cfuncproto( 17079 load_so_libforms(), "fl_add_xyplot", 17080 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 17081 FL_Coord, STRING], 17082 """FL_OBJECT * fl_add_xyplot(int t, FL_Coord x, FL_Coord y, 17083 FL_Coord w, FL_Coord h, const char * label) 17084 """) 17085 check_admitted_listvalues(plottype, XYPLOTTYPE_list) 17086 iplottype = convert_to_int(plottype) 17087 ix = convert_to_FL_Coord(x) 17088 iy = convert_to_FL_Coord(y) 17089 iw = convert_to_FL_Coord(w) 17090 ih = convert_to_FL_Coord(h) 17091 slabel = convert_to_string(label) 17092 keep_elem_refs(plottype, x, y, w, h, label, iplottype, ix, iy, 17093 iw, ih, slabel) 17094 retval = _fl_add_xyplot(iplottype, ix, iy, iw, ih, slabel) 17095 return retval
17096 17097
17098 -def fl_set_xyplot_data(pObject, xlist, ylist, n, title, xlabel, ylabel):
17099 """ 17100 fl_set_xyplot_data(pObject, xlist, ylist, n, title, xlabel, ylabel) 17101 17102 @param pObject : pointer to object 17103 """ 17104 17105 _fl_set_xyplot_data = cfuncproto( 17106 load_so_libforms(), "fl_set_xyplot_data", 17107 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17108 cty.POINTER(cty.c_float), cty.c_int, STRING, STRING, STRING], 17109 """void fl_set_xyplot_data(FL_OBJECT * ob, float * x, float * y, 17110 int n, const char * title, const char * xlabel, 17111 const char * ylabel) 17112 """) 17113 #px = cty.cast(x, cty.POINTER(cty.c_float)) 17114 print xlist, xlist[0] 17115 fx = [] 17116 for a in range(xlist): 17117 fx[a] = convert_to_float(xlist[a]) 17118 px = cty.pointer(fx) 17119 print "x, fx, px", xlist, fx, px 17120 #py = cty.cast(y, cty.POINTER(cty.c_float)) 17121 fy = [] 17122 for a in range(ylist): 17123 fy[a] = convert_to_float(ylist[a]) 17124 py = cty.pointer(fy) 17125 print "y, fy, py", ylist, fy, py 17126 inum = convert_to_int(n) 17127 stitle = convert_to_string(title) 17128 sxlabel = convert_to_string(xlabel) 17129 sylabel = convert_to_string(ylabel) 17130 keep_elem_refs(pObject, xlist, ylist, n, fx, fy, px, py, title, \ 17131 xlabel, ylabel, inum, stitle, sxlabel, sylabel) 17132 _fl_set_xyplot_data(pObject, px, py, inum, stitle, sxlabel, sylabel)
17133 17134
17135 -def fl_set_xyplot_data_double(pObject, x, y, n, title, xlabel, ylabel):
17136 """ fl_set_xyplot_data_double(pObject, x, y, n, title, xlabel, ylabel) 17137 17138 @param pObject : pointer to object 17139 """ 17140 17141 _fl_set_xyplot_data_double = cfuncproto( 17142 load_so_libforms(), "fl_set_xyplot_data_double", 17143 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 17144 cty.POINTER(cty.c_double), cty.c_int, STRING, STRING, STRING], 17145 """void fl_set_xyplot_data_double(FL_OBJECT * ob, double * x, 17146 double * y, int n, const char * title, const char * xlabel, 17147 const char * ylabel) 17148 """) 17149 px = cty.cast(x, cty.POINTER(cty.c_double)) 17150 py = cty.cast(y, cty.POINTER(cty.c_double)) 17151 inum = convert_to_int(n) 17152 stitle = convert_to_string(title) 17153 sxlabel = convert_to_string(xlabel) 17154 sylabel = convert_to_string(ylabel) 17155 keep_elem_refs(pObject, x, y, n, title, xlabel, ylabel, px, py, inum, \ 17156 stitle, sxlabel, sylabel) 17157 _fl_set_xyplot_data_double(pObject, px, py, n, title, \ 17158 xlabel, ylabel, inum, stitle, \ 17159 sxlabel, sylabel)
17160 17161
17162 -def fl_set_xyplot_file(pObject, f, title, xl, yl):
17163 """ fl_set_xyplot_file(pObject, f, title, xl, yl) -> num. 17164 17165 @param pObject : pointer to object 17166 """ 17167 17168 _fl_set_xyplot_file = cfuncproto( 17169 load_so_libforms(), "fl_set_xyplot_file", 17170 cty.c_int, [cty.POINTER(FL_OBJECT), STRING, STRING, STRING, 17171 STRING], 17172 """int fl_set_xyplot_file(FL_OBJECT * ob, const char * f, 17173 const char * title, const char * xl, const char * yl) 17174 """) 17175 sf = convert_to_string(f) 17176 stitle = convert_to_string(title) 17177 sxl = convert_to_string(xl) 17178 syl = convert_to_string(yl) 17179 keep_elem_refs(pObject, f, title, xl, yl, sf, stitle, sxl, syl) 17180 retval = _fl_set_xyplot_file(pObject, sf, stitle, sxl, syl) 17181 return retval
17182 17183
17184 -def fl_insert_xyplot_data(pObject, idnum, n, valx, valy):
17185 """ 17186 fl_insert_xyplot_data(pObject, idnum, n, valx, valy) 17187 17188 @param pObject : pointer to object 17189 """ 17190 17191 _fl_insert_xyplot_data = cfuncproto( 17192 load_so_libforms(), "fl_insert_xyplot_data", 17193 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, cty.c_double, 17194 cty.c_double], 17195 """void fl_insert_xyplot_data(FL_OBJECT * ob, int id, int n, 17196 double x, double y) 17197 """) 17198 iidnum = convert_to_int(idnum) 17199 inum = convert_to_int(n) 17200 fvalx = convert_to_double(valx) 17201 fvaly = convert_to_double(valy) 17202 keep_elem_refs(pObject, idnum, n, valx, valy, iidnum, inum, fvalx, fvaly) 17203 _fl_insert_xyplot_data(pObject, iidnum, inum, fvalx, fvaly)
17204 17205
17206 -def fl_add_xyplot_text(pObject, valx, valy, text, al, colr):
17207 """ 17208 fl_add_xyplot_text(pObject, valx, valy, text, al, colr) 17209 17210 @param pObject : pointer to object 17211 """ 17212 17213 _fl_add_xyplot_text = cfuncproto( 17214 load_so_libforms(), "fl_add_xyplot_text", 17215 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, STRING, 17216 cty.c_int, FL_COLOR], 17217 """void fl_add_xyplot_text(FL_OBJECT * ob, double x, double y, 17218 const char * text, int al, FL_COLOR col) 17219 """) 17220 fvalx = convert_to_double(valx) 17221 fvaly = convert_to_double(valy) 17222 stext = convert_to_string(text) 17223 ial = convert_to_int(al) 17224 ulcolr = convert_to_FL_COLOR(colr) 17225 keep_elem_refs(pObject, valx, valy, text, al, colr, fvalx, fvaly, \ 17226 stext, ial, ulcolr) 17227 _fl_add_xyplot_text(pObject, fvalx, fvaly, stext, ial, ulcolr)
17228 17229
17230 -def fl_delete_xyplot_text(pObject, text):
17231 """ 17232 fl_delete_xyplot_text(pObject, text) 17233 17234 @param pObject : pointer to object 17235 """ 17236 17237 _fl_delete_xyplot_text = cfuncproto( 17238 load_so_libforms(), "fl_delete_xyplot_text", 17239 None, [cty.POINTER(FL_OBJECT), STRING], 17240 """void fl_delete_xyplot_text(FL_OBJECT * ob, const char * text) 17241 """) 17242 stext = convert_to_string(text) 17243 keep_elem_refs(pObject, text, stext) 17244 _fl_delete_xyplot_text(pObject, stext)
17245 17246
17247 -def fl_set_xyplot_maxoverlays(pObject, maxover):
17248 """ 17249 fl_set_xyplot_maxoverlays(pObject, maxover) -> num. 17250 17251 @param pObject : pointer to object 17252 """ 17253 17254 _fl_set_xyplot_maxoverlays = cfuncproto( 17255 load_so_libforms(), "fl_set_xyplot_maxoverlays", 17256 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 17257 """int fl_set_xyplot_maxoverlays(FL_OBJECT * ob, int maxover) 17258 """) 17259 imaxover = convert_to_int(maxover) 17260 keep_elem_refs(pObject, maxover, imaxover) 17261 retval = _fl_set_xyplot_maxoverlays(pObject, imaxover) 17262 return retval
17263 17264
17265 -def fl_add_xyplot_overlay(pObject, idnum, x, y, n, colr):
17266 """ 17267 fl_add_xyplot_overlay(pObject, idnum, x, y, n, colr) 17268 17269 @param pObject : pointer to object 17270 """ 17271 17272 _fl_add_xyplot_overlay = cfuncproto( 17273 load_so_libforms(), "fl_add_xyplot_overlay", 17274 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(cty.c_float), 17275 cty.POINTER(cty.c_float), cty.c_int, FL_COLOR], 17276 """void fl_add_xyplot_overlay(FL_OBJECT * ob, int id, float * x, 17277 float * y, int n, FL_COLOR col) 17278 """) 17279 iidnum = convert_to_int(idnum) 17280 px = cty.cast(x, cty.POINTER(cty.c_float)) 17281 py = cty.cast(y, cty.POINTER(cty.c_float)) 17282 inum = convert_to_int(n) 17283 ulcolr = convert_to_FL_COLOR(colr) 17284 keep_elem_refs(pObject, idnum, x, y, n, colr, iidnum, px, py, inum, \ 17285 ulcolr) 17286 _fl_add_xyplot_overlay(pObject, iidnum, px, py, inum, ulcolr)
17287 17288
17289 -def fl_add_xyplot_overlay_file(pObject, idnum, f, colr):
17290 """ 17291 fl_add_xyplot_overlay_file(pObject, idnum, f, colr) -> num. 17292 17293 @param pObject : pointer to object 17294 """ 17295 17296 _fl_add_xyplot_overlay_file = cfuncproto( 17297 load_so_libforms(), "fl_add_xyplot_overlay_file", 17298 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, STRING, FL_COLOR], 17299 """int fl_add_xyplot_overlay_file(FL_OBJECT * ob, int id, 17300 const char * f, FL_COLOR c) 17301 """) 17302 iidnum = convert_to_int(idnum) 17303 sf = convert_to_string(f) 17304 ulcolr = convert_to_FL_COLOR(colr) 17305 keep_elem_refs(pObject, idnum, f, colr, iidnum, sf, ulcolr) 17306 retval = _fl_add_xyplot_overlay_file(pObject, iidnum, sf, ulcolr) 17307 return retval
17308 17309
17310 -def fl_set_xyplot_return(pObject, when):
17311 """ 17312 fl_set_xyplot_return(pObject, when) 17313 17314 @param pObject : pointer to object 17315 """ 17316 17317 _fl_set_xyplot_return = cfuncproto( 17318 load_so_libforms(), "fl_set_xyplot_return", 17319 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17320 """void fl_set_xyplot_return(FL_OBJECT * ob, int when) 17321 """) 17322 iwhen = convert_to_int(when) 17323 keep_elem_refs(pObject, when, iwhen) 17324 _fl_set_xyplot_return(pObject, iwhen)
17325 17326
17327 -def fl_set_xyplot_xtics(pObject, major, minor):
17328 """ 17329 fl_set_xyplot_xtics(pObject, major, minor) 17330 17331 @param pObject : pointer to object 17332 """ 17333 17334 _fl_set_xyplot_xtics = cfuncproto( 17335 load_so_libforms(), "fl_set_xyplot_xtics", 17336 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 17337 """void fl_set_xyplot_xtics(FL_OBJECT * ob, int major, int minor) 17338 """) 17339 imajor = convert_to_int(major) 17340 iminor = convert_to_int(minor) 17341 keep_elem_refs(pObject, major, minor, imajor, iminor) 17342 _fl_set_xyplot_xtics(pObject, imajor, iminor)
17343 17344
17345 -def fl_set_xyplot_ytics(pObject, major, minor):
17346 """ 17347 fl_set_xyplot_ytics(pObject, major, minor) 17348 17349 @param pObject : pointer to object 17350 """ 17351 17352 _fl_set_xyplot_ytics = cfuncproto( 17353 load_so_libforms(), "fl_set_xyplot_ytics", 17354 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 17355 """void fl_set_xyplot_ytics(FL_OBJECT * ob, int major, int minor) 17356 """) 17357 imajor = convert_to_int(major) 17358 iminor = convert_to_int(minor) 17359 keep_elem_refs(pObject, major, minor, imajor, iminor) 17360 _fl_set_xyplot_ytics(pObject, imajor, iminor)
17361 17362
17363 -def fl_set_xyplot_xbounds(pObject, minbound, maxbound):
17364 """ 17365 fl_set_xyplot_xbounds(pObject, minbound, maxbound) 17366 17367 @param pObject : pointer to object 17368 """ 17369 17370 _fl_set_xyplot_xbounds = cfuncproto( 17371 load_so_libforms(), "fl_set_xyplot_xbounds", 17372 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 17373 """void fl_set_xyplot_xbounds(FL_OBJECT * ob, double xmin, 17374 double xmax) 17375 """) 17376 fminbound = convert_to_double(minbound) 17377 fmaxbound = convert_to_double(maxbound) 17378 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 17379 _fl_set_xyplot_xbounds(pObject, fminbound, fmaxbound)
17380 17381
17382 -def fl_set_xyplot_ybounds(pObject, minbound, maxbound):
17383 """ 17384 fl_set_xyplot_ybounds(pObject, minbound, maxbound) 17385 17386 @param pObject : pointer to object 17387 """ 17388 17389 _fl_set_xyplot_ybounds = cfuncproto( 17390 load_so_libforms(), "fl_set_xyplot_ybounds", 17391 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 17392 """void fl_set_xyplot_ybounds(FL_OBJECT * ob, double ymin, 17393 double ymax) 17394 """) 17395 fminbound = convert_to_double(minbound) 17396 fmaxbound = convert_to_double(maxbound) 17397 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 17398 _fl_set_xyplot_ybounds(pObject, fminbound, fmaxbound)
17399 17400 17401 #def fl_get_xyplot_xbounds(pObject, minbound, maxbound) *API change*
17402 -def fl_get_xyplot_xbounds(pObject):
17403 """ 17404 fl_get_xyplot_xbounds(pObject) -> minbound, maxbound 17405 17406 @param pObject : pointer to object 17407 """ 17408 17409 _fl_get_xyplot_xbounds = cfuncproto( 17410 load_so_libforms(), "fl_get_xyplot_xbounds", 17411 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17412 cty.POINTER(cty.c_float)], 17413 """void fl_get_xyplot_xbounds(FL_OBJECT * ob, float * xmin, 17414 float * xmax) 17415 """) 17416 minbound, pminbound = make_float_and_pointer() 17417 maxbound, pmaxbound = make_float_and_pointer() 17418 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 17419 _fl_get_xyplot_xbounds(pObject, pminbound, pmaxbound) 17420 return minbound, maxbound
17421 17422 17423 #def fl_get_xyplot_ybounds(pObject, minbound, maxbound) *API change*
17424 -def fl_get_xyplot_ybounds(pObject):
17425 """ 17426 fl_get_xyplot_ybounds(pObject) -> minbound, maxbound 17427 17428 @param pObject : pointer to object 17429 """ 17430 17431 _fl_get_xyplot_ybounds = cfuncproto( 17432 load_so_libforms(), "fl_get_xyplot_ybounds", 17433 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17434 cty.POINTER(cty.c_float)], 17435 """void fl_get_xyplot_ybounds(FL_OBJECT * ob, float * ymin, 17436 float * ymax) 17437 """) 17438 minbound, pminbound = make_float_and_pointer() 17439 maxbound, pmaxbound = make_float_and_pointer() 17440 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 17441 _fl_get_xyplot_ybounds(pObject, pminbound, pmaxbound) 17442 return minbound, maxbound
17443 17444 17445 #def fl_get_xyplot(pObject, x, y, i) *API change*
17446 -def fl_get_xyplot(pObject):
17447 """ 17448 fl_get_xyplot(pObject) -> x, y, i 17449 17450 @param pObject : pointer to object 17451 """ 17452 17453 _fl_get_xyplot = cfuncproto( 17454 load_so_libforms(), "fl_get_xyplot", 17455 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17456 cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 17457 """void fl_get_xyplot(FL_OBJECT * ob, float * x, float * y, 17458 int * i) 17459 """) 17460 x, px = make_float_and_pointer() 17461 y, py = make_float_and_pointer() 17462 i, pi = make_int_and_pointer() 17463 keep_elem_refs(pObject, x, y, i, px, py, pi) 17464 _fl_get_xyplot(pObject, px, py, pi) 17465 return x, y, i
17466 17467 17468 #def fl_get_xyplot_data(pObject, x, y, n) *API change*
17469 -def fl_get_xyplot_data(pObject):
17470 """ 17471 fl_get_xyplot_data(pObject) -> x, y, n 17472 17473 @param pObject : pointer to object 17474 """ 17475 17476 _fl_get_xyplot_data = cfuncproto( 17477 load_so_libforms(), "fl_get_xyplot_data", 17478 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17479 cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 17480 """void fl_get_xyplot_data(FL_OBJECT * ob, float * x, float * y, 17481 int * n) 17482 """) 17483 x, px = make_float_and_pointer() 17484 y, py = make_float_and_pointer() 17485 n, pn = make_int_and_pointer() 17486 keep_elem_refs(pObject, x, y, n, px, py, pn) 17487 _fl_get_xyplot_data(pObject, px, py, pn) 17488 return x, y, n
17489 17490 17491 #def fl_get_xyplot_data_pointer(pObject, idnum, x, y, n) *API change*
17492 -def fl_get_xyplot_data_pointer(pObject, idnum):
17493 """ 17494 fl_get_xyplot_data_pointer(pObject, idnum) -> x, y, n 17495 17496 @param pObject : pointer to object 17497 """ 17498 17499 _fl_get_xyplot_data_pointer = cfuncproto( 17500 load_so_libforms(), "fl_get_xyplot_data_pointer", 17501 None, [cty.POINTER(FL_OBJECT), cty.c_int, 17502 cty.POINTER(cty.POINTER(cty.c_float)), 17503 cty.POINTER(cty.POINTER(cty.c_float)), cty.POINTER(cty.c_int)], 17504 """void fl_get_xyplot_data_cty.POINTER(FL_OBJECT * ob, int id, 17505 float * * x, float * * y, int * n) 17506 """) 17507 iidnum = convert_to_int(idnum) 17508 x, px = make_float_and_pointer() 17509 y, py = make_float_and_pointer() 17510 n, pn = make_int_and_pointer() 17511 keep_elem_refs(pObject, idnum, iidnum, x, y, n, px, py, pn) 17512 _fl_get_xyplot_data_pointer(pObject, iidnum, px, py, pn) 17513 return x, y, n
17514 17515 17516 #def fl_get_xyplot_overlay_data(pObject, idnum, x, y, n) *API change*
17517 -def fl_get_xyplot_overlay_data(pObject, idnum):
17518 """ 17519 fl_get_xyplot_overlay_data(pObject, idnum) -> x, y, n 17520 17521 @param pObject : pointer to object 17522 """ 17523 17524 _fl_get_xyplot_overlay_data = cfuncproto( 17525 load_so_libforms(), "fl_get_xyplot_overlay_data", 17526 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(cty.c_float), 17527 cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 17528 """void fl_get_xyplot_overlay_data(FL_OBJECT * ob, int id, 17529 float * x, float * y, int * n) 17530 """) 17531 iidnum = convert_to_int(idnum) 17532 x, px = make_float_and_pointer() 17533 y, py = make_float_and_pointer() 17534 n, pn = make_int_and_pointer() 17535 keep_elem_refs(pObject, idnum, iidnum, x, y, n, px, py, pn) 17536 _fl_get_xyplot_overlay_data(pObject, iidnum, px, py, pn) 17537 return x, y, n
17538 17539
17540 -def fl_set_xyplot_overlay_type(pObject, idnum, plottype):
17541 """ 17542 fl_set_xyplot_overlay_type(pObject, idnum, plottype) 17543 17544 @param pObject : pointer to object 17545 """ 17546 17547 _fl_set_xyplot_overlay_type = cfuncproto( 17548 load_so_libforms(), "fl_set_xyplot_overlay_type", 17549 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 17550 """void fl_set_xyplot_overlay_type(FL_OBJECT * ob, int id, 17551 int type) 17552 """) 17553 iidnum = convert_to_int(idnum) 17554 iplottype = convert_to_int(plottype) 17555 keep_elem_refs(pObject, idnum, plottype, iidnum, iplottype) 17556 _fl_set_xyplot_overlay_type(pObject, iidnum, iplottype)
17557 17558
17559 -def fl_delete_xyplot_overlay(pObject, idnum):
17560 """ 17561 fl_delete_xyplot_overlay(pObject, idnum) 17562 17563 @param pObject : pointer to object 17564 """ 17565 17566 _fl_delete_xyplot_overlay = cfuncproto( 17567 load_so_libforms(), "fl_delete_xyplot_overlay", 17568 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17569 """void fl_delete_xyplot_overlay(FL_OBJECT * ob, int id) 17570 """) 17571 iidnum = convert_to_int(idnum) 17572 keep_elem_refs(pObject, idnum, iidnum) 17573 _fl_delete_xyplot_overlay(pObject, iidnum)
17574 17575
17576 -def fl_set_xyplot_interpolate(pObject, idnum, deg, grid):
17577 """ 17578 fl_set_xyplot_interpolate(pObject, idnum, deg, grid) 17579 17580 @param pObject : pointer to object 17581 """ 17582 17583 _fl_set_xyplot_interpolate = cfuncproto( 17584 load_so_libforms(), "fl_set_xyplot_interpolate", 17585 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 17586 cty.c_double], 17587 """void fl_set_xyplot_interpolate(FL_OBJECT * ob, int id, 17588 int deg, double grid) 17589 """) 17590 iidnum = convert_to_int(idnum) 17591 ideg = convert_to_int(deg) 17592 fgrid = convert_to_double(grid) 17593 keep_elem_refs(pObject, idnum, deg, grid, iidnum, ideg, fgrid) 17594 _fl_set_xyplot_interpolate(pObject, iidnum, ideg, fgrid)
17595 17596
17597 -def fl_set_xyplot_inspect(pObject, yes):
17598 """ 17599 fl_set_xyplot_inspect(pObject, yes) 17600 17601 @param pObject : pointer to object 17602 """ 17603 17604 _fl_set_xyplot_inspect = cfuncproto( 17605 load_so_libforms(), "fl_set_xyplot_inspect", 17606 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17607 """void fl_set_xyplot_inspect(FL_OBJECT * ob, int yes) 17608 """) 17609 iyes = convert_to_int(yes) 17610 keep_elem_refs(pObject, yes, iyes) 17611 _fl_set_xyplot_inspect(pObject, iyes)
17612 17613
17614 -def fl_set_xyplot_symbolsize(pObject, n):
17615 """ 17616 fl_set_xyplot_symbolsize(pObject, n) 17617 17618 @param pObject : pointer to object 17619 """ 17620 17621 _fl_set_xyplot_symbolsize = cfuncproto( 17622 load_so_libforms(), "fl_set_xyplot_symbolsize", 17623 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17624 """void fl_set_xyplot_symbolsize(FL_OBJECT * ob, int n) 17625 """) 17626 inum = convert_to_int(n) 17627 keep_elem_refs(pObject, n, inum) 17628 _fl_set_xyplot_symbolsize(pObject, inum)
17629 17630
17631 -def fl_replace_xyplot_point(pObject, i, valx, valy):
17632 """ 17633 fl_replace_xyplot_point(pObject, i, valx, valy) 17634 17635 @param pObject : pointer to object 17636 """ 17637 17638 _fl_replace_xyplot_point = cfuncproto( 17639 load_so_libforms(), "fl_replace_xyplot_point", 17640 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, 17641 cty.c_double], 17642 """void fl_replace_xyplot_point(FL_OBJECT * ob, int i, 17643 double x, double y) 17644 """) 17645 ii = convert_to_int(i) 17646 fvalx = convert_to_double(valx) 17647 fvaly = convert_to_double(valy) 17648 keep_elem_refs(pObject, i, valx, valy, ii, fvalx, fvaly) 17649 _fl_replace_xyplot_point(pObject, ii, fvalx, fvaly)
17650 17651 17652 # Replace the value of a particular point in dataset setID, 17653 # where setID=0 is the first data set. 17654 # This routine is an extension of fl_replace_xyplot_point 17655 # which acts on the first dataset only. 17656
17657 -def fl_replace_xyplot_point_in_overlay(pObject, i, setID, valx, valy):
17658 """ 17659 fl_replace_xyplot_point_in_overlay(pObject, i, setID, valx, valy) 17660 17661 @param pObject : pointer to object 17662 """ 17663 17664 _fl_replace_xyplot_point_in_overlay = cfuncproto( 17665 load_so_libforms(), "fl_replace_xyplot_point_in_overlay", 17666 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, \ 17667 cty.c_double, cty.c_double], 17668 """void fl_replace_xyplot_point_in_overlay(FL_OBJECT * ob, 17669 int i, int setID, double x, double y) 17670 """) 17671 ii = convert_to_int(i) 17672 isetID = convert_to_int(setID) 17673 fvalx = convert_to_double(valx) 17674 fvaly = convert_to_double(valy) 17675 keep_elem_refs(pObject, i, setID, valx, valy, ii, isetID, fvalx, fvaly) 17676 _fl_replace_xyplot_point_in_overlay(pObject, ii, isetID, fvalx, fvaly)
17677 17678 17679 #def fl_get_xyplot_xmapping(pObject, a, b) *API change*
17680 -def fl_get_xyplot_xmapping(pObject):
17681 """ 17682 fl_get_xyplot_xmapping(pObject) -> a, b 17683 17684 @param pObject : pointer to object 17685 """ 17686 17687 _fl_get_xyplot_xmapping = cfuncproto( 17688 load_so_libforms(), "fl_get_xyplot_xmapping", 17689 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17690 cty.POINTER(cty.c_float)], 17691 """void fl_get_xyplot_xmapping(FL_OBJECT * ob, float * a, 17692 float * b) 17693 """) 17694 a, pa = make_float_and_pointer() 17695 b, pb = make_float_and_pointer() 17696 keep_elem_refs(pObject, a, b, pa, pb) 17697 _fl_get_xyplot_xmapping(pObject, pa, pb) 17698 return a, b
17699 17700 17701 #def fl_get_xyplot_ymapping(pObject, a, b) *API change*
17702 -def fl_get_xyplot_ymapping(pObject):
17703 """ 17704 fl_get_xyplot_ymapping(pObject) -> a, b 17705 17706 @param pObject : pointer to object 17707 """ 17708 17709 _fl_get_xyplot_ymapping = cfuncproto( 17710 load_so_libforms(), "fl_get_xyplot_ymapping", 17711 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17712 cty.POINTER(cty.c_float)], 17713 """void fl_get_xyplot_ymapping(FL_OBJECT * ob, float * a, 17714 float * b) 17715 """) 17716 a, pa = make_float_and_pointer() 17717 b, pb = make_float_and_pointer() 17718 keep_elem_refs(pObject, a, b, pa, pb) 17719 _fl_get_xyplot_ymapping(pObject, pa, pb) 17720 return a, b
17721 17722
17723 -def fl_set_xyplot_keys(pObject, keys, valx, valy, align):
17724 """ 17725 fl_set_xyplot_keys(pObject, keys, valx, valy, align) 17726 17727 @param pObject : pointer to object 17728 """ 17729 17730 _fl_set_xyplot_keys = cfuncproto( 17731 load_so_libforms(), "fl_set_xyplot_keys", 17732 None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING), cty.c_float, 17733 cty.c_float, cty.c_int], 17734 """void fl_set_xyplot_keys(FL_OBJECT * ob, char * * keys, float x, 17735 float y, int align) 17736 """) 17737 fvalx = convert_to_float(valx) 17738 fvaly = convert_to_float(valy) 17739 ialign = convert_to_int(align) 17740 keep_elem_refs(pObject, keys, valx, valy, align, fvalx, fvaly, ialign) 17741 _fl_set_xyplot_keys(pObject, keys, fvalx, fvaly, ialign)
17742 17743
17744 -def fl_set_xyplot_key(pObject, idnum, keytxt):
17745 """ 17746 fl_set_xyplot_key(pObject, idnum, keytxt) 17747 17748 @param pObject : pointer to object 17749 """ 17750 17751 _fl_set_xyplot_key = cfuncproto( 17752 load_so_libforms(), "fl_set_xyplot_key", 17753 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 17754 """void fl_set_xyplot_key(FL_OBJECT * ob, int id, 17755 const char * key) 17756 """) 17757 iidnum = convert_to_int(idnum) 17758 skeytxt = convert_to_string(keytxt) 17759 keep_elem_refs(pObject, idnum, keytxt, iidnum, skeytxt) 17760 _fl_set_xyplot_key(pObject, iidnum, skeytxt)
17761 17762
17763 -def fl_set_xyplot_key_position(pObject, valx, valy, align):
17764 """ 17765 fl_set_xyplot_key_position(pObject, valx, valy, align) 17766 17767 @param pObject : pointer to object 17768 """ 17769 17770 _fl_set_xyplot_key_position = cfuncproto( 17771 load_so_libforms(), "fl_set_xyplot_key_position", 17772 None, [cty.POINTER(FL_OBJECT), cty.c_float, cty.c_float, 17773 cty.c_int], 17774 """void fl_set_xyplot_key_position(FL_OBJECT * ob, float x, 17775 float y, int align) 17776 """) 17777 fvalx = convert_to_float(valx) 17778 fvaly = convert_to_float(valy) 17779 ialign = convert_to_int(align) 17780 keep_elem_refs(pObject, valx, valy, align, fvalx, fvaly, ialign) 17781 _fl_set_xyplot_key_position(pObject, fvalx, fvaly, ialign)
17782 17783
17784 -def fl_set_xyplot_key_font(pObject, style, size):
17785 """ 17786 fl_set_xyplot_key_font(pObject, style, size) 17787 17788 @param pObject : pointer to object 17789 """ 17790 17791 _fl_set_xyplot_key_font = cfuncproto( 17792 load_so_libforms(), "fl_set_xyplot_key_font", 17793 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 17794 """void fl_set_xyplot_key_font(FL_OBJECT * ob, int style, 17795 int size) 17796 """) 17797 istyle = convert_to_int(style) 17798 isize = convert_to_int(size) 17799 keep_elem_refs(pObject, style, size, istyle, isize) 17800 _fl_set_xyplot_key_font(pObject, istyle, isize)
17801 17802
17803 -def fl_get_xyplot_numdata(pObject, idnum):
17804 """ 17805 fl_get_xyplot_numdata(pObject, idnum) -> num. 17806 17807 @param pObject : pointer to object 17808 """ 17809 17810 _fl_get_xyplot_numdata = cfuncproto( 17811 load_so_libforms(), "fl_get_xyplot_numdata", 17812 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 17813 """int fl_get_xyplot_numdata(FL_OBJECT * ob, int id) 17814 """) 17815 iidnum = convert_to_int(idnum) 17816 keep_elem_refs(pObject, idnum, iidnum) 17817 retval = _fl_get_xyplot_numdata(pObject, iidnum) 17818 return retval
17819 17820 17821 # The following two functions will be removed. 17822 # Use fl_set_object_l[size|style] for the functionalities 17823
17824 -def fl_set_xyplot_fontsize(pObject, size):
17825 """ 17826 fl_set_xyplot_fontsize(pObject, size) 17827 17828 @param pObject : pointer to object 17829 """ 17830 17831 _fl_set_xyplot_fontsize = cfuncproto( 17832 load_so_libforms(), "fl_set_xyplot_fontsize", 17833 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17834 """void fl_set_xyplot_fontsize(FL_OBJECT * ob, int size) DEPRECATED 17835 """) 17836 warn_deprecated_function("Use fl_set_lsize, instead.") 17837 isize = convert_to_int(size) 17838 keep_elem_refs(pObject, size, isize) 17839 _fl_set_xyplot_fontsize(pObject, isize)
17840 17841
17842 -def fl_set_xyplot_fontstyle(pObject, style):
17843 """ 17844 fl_set_xyplot_fontstyle(pObject, style) 17845 17846 @param pObject : pointer to object 17847 """ 17848 17849 _fl_set_xyplot_fontstyle = cfuncproto( 17850 load_so_libforms(), "fl_set_xyplot_fontstyle", 17851 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17852 """void fl_set_xyplot_fontstyle(FL_OBJECT * ob, int style) DEPRECATED 17853 """) 17854 warn_deprecated_function("Use fl_set_lstyle, instead.") 17855 istyle = convert_to_int(style) 17856 keep_elem_refs(pObject, style, istyle) 17857 _fl_set_xyplot_fontstyle(pObject, istyle)
17858 17859
17860 -def fl_xyplot_s2w(pObject, sx, sy, wx, wy):
17861 """ 17862 fl_xyplot_s2w(pObject, sx, sy, wx, wy) 17863 17864 @param pObject : pointer to object 17865 """ 17866 17867 _fl_xyplot_s2w = cfuncproto( 17868 load_so_libforms(), "fl_xyplot_s2w", 17869 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, 17870 cty.POINTER(cty.c_float), cty.POINTER(cty.c_float)], 17871 """void fl_xyplot_s2w(FL_OBJECT * ob, double sx, double sy, 17872 float * wx, float * wy) 17873 """) 17874 fsx = convert_to_double(sx) 17875 fsy = convert_to_double(sy) 17876 keep_elem_refs(pObject, sx, sy, wx, wy, fsx, fsy) 17877 _fl_xyplot_s2w(pObject, fsx, fsy, wx, wy)
17878 17879
17880 -def fl_xyplot_w2s(pObject, wx, wy, sx, sy):
17881 """ 17882 fl_xyplot_w2s(pObject, wx, wy, sx, sy) 17883 17884 @param pObject : pointer to object 17885 """ 17886 17887 _fl_xyplot_w2s = cfuncproto( 17888 load_so_libforms(), "fl_xyplot_w2s", 17889 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, 17890 cty.POINTER(cty.c_float), cty.POINTER(cty.c_float)], 17891 """void fl_xyplot_w2s(FL_OBJECT * ob, double wx, double wy, 17892 float * sx, float * sy) 17893 """) 17894 fwx = convert_to_double(wx) 17895 fwy = convert_to_double(wy) 17896 keep_elem_refs(pObject, wx, wy, sx, sy, fwx, fwy) 17897 _fl_xyplot_w2s(pObject, fwx, fwy, sx, sy)
17898 17899
17900 -def fl_set_xyplot_xscale(pObject, scale, base):
17901 """ 17902 fl_set_xyplot_xscale(pObject, scale, base) 17903 17904 @param pObject : pointer to object 17905 """ 17906 17907 _fl_set_xyplot_xscale = cfuncproto( 17908 load_so_libforms(), "fl_set_xyplot_xscale", 17909 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double], 17910 """void fl_set_xyplot_xscale(FL_OBJECT * ob, int scale, 17911 double base) 17912 """) 17913 iscale = convert_to_int(scale) 17914 fbase = convert_to_double(base) 17915 keep_elem_refs(pObject, scale, base, iscale, fbase) 17916 _fl_set_xyplot_xscale(pObject, iscale, fbase)
17917 17918
17919 -def fl_set_xyplot_yscale(pObject, scale, base):
17920 """ 17921 fl_set_xyplot_yscale(pObject, scale, base) 17922 17923 @param pObject : pointer to object 17924 """ 17925 17926 _fl_set_xyplot_yscale = cfuncproto( 17927 load_so_libforms(), "fl_set_xyplot_yscale", 17928 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double], 17929 """void fl_set_xyplot_yscale(FL_OBJECT * ob, int scale, 17930 double base) 17931 """) 17932 iscale = convert_to_int(scale) 17933 fbase = convert_to_double(base) 17934 keep_elem_refs(pObject, scale, base, iscale, fbase) 17935 _fl_set_xyplot_yscale(pObject, iscale, fbase)
17936 17937
17938 -def fl_clear_xyplot(pObject):
17939 """ 17940 fl_clear_xyplot(pObject) 17941 17942 @param pObject : pointer to object 17943 """ 17944 17945 _fl_clear_xyplot = cfuncproto( 17946 load_so_libforms(), "fl_clear_xyplot", 17947 None, [cty.POINTER(FL_OBJECT)], 17948 """void fl_clear_xyplot(FL_OBJECT * ob) 17949 """) 17950 keep_elem_refs(pObject) 17951 _fl_clear_xyplot(pObject)
17952 17953
17954 -def fl_set_xyplot_linewidth(pObject, idnum, lw):
17955 """ 17956 fl_set_xyplot_linewidth(pObject, idnum, lw) 17957 17958 @param pObject : pointer to object 17959 """ 17960 17961 _fl_set_xyplot_linewidth = cfuncproto( 17962 load_so_libforms(), "fl_set_xyplot_linewidth", 17963 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 17964 """void fl_set_xyplot_linewidth(FL_OBJECT * ob, int id, int lw) 17965 """) 17966 iidnum = convert_to_int(idnum) 17967 ilw = convert_to_int(lw) 17968 keep_elem_refs(pObject, idnum, lw, iidnum, ilw) 17969 _fl_set_xyplot_linewidth(pObject, iidnum, ilw)
17970 17971
17972 -def fl_set_xyplot_xgrid(pObject, xgrid):
17973 """ 17974 fl_set_xyplot_xgrid(pObject, xgrid) 17975 17976 @param pObject : pointer to object 17977 """ 17978 17979 _fl_set_xyplot_xgrid = cfuncproto( 17980 load_so_libforms(), "fl_set_xyplot_xgrid", 17981 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17982 """void fl_set_xyplot_xgrid(FL_OBJECT * ob, int xgrid) 17983 """) 17984 ixgrid = convert_to_int(xgrid) 17985 keep_elem_refs(pObject, xgrid, ixgrid) 17986 _fl_set_xyplot_xgrid(pObject, ixgrid)
17987 17988
17989 -def fl_set_xyplot_ygrid(pObject, ygrid):
17990 """ 17991 fl_set_xyplot_ygrid(pObject, ygrid) 17992 17993 @param pObject : pointer to object 17994 """ 17995 17996 _fl_set_xyplot_ygrid = cfuncproto( 17997 load_so_libforms(), "fl_set_xyplot_ygrid", 17998 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17999 """void fl_set_xyplot_ygrid(FL_OBJECT * ob, int ygrid) 18000 """) 18001 iygrid = convert_to_int(ygrid) 18002 keep_elem_refs(pObject, ygrid, iygrid) 18003 _fl_set_xyplot_ygrid(pObject, iygrid)
18004 18005
18006 -def fl_set_xyplot_grid_linestyle(pObject, style):
18007 """ 18008 fl_set_xyplot_grid_linestyle(pObject, style) -> num. 18009 18010 @param pObject : pointer to object 18011 """ 18012 18013 _fl_set_xyplot_grid_linestyle = cfuncproto( 18014 load_so_libforms(), "fl_set_xyplot_grid_linestyle", 18015 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 18016 """int fl_set_xyplot_grid_linestyle(FL_OBJECT * ob, int style) 18017 """) 18018 istyle = convert_to_int(style) 18019 keep_elem_refs(pObject, style, istyle) 18020 retval = _fl_set_xyplot_grid_linestyle(pObject, istyle) 18021 return retval
18022 18023
18024 -def fl_set_xyplot_alphaxtics(pObject, m, s):
18025 """ 18026 fl_set_xyplot_alphaxtics(pObject, m, s) 18027 18028 @param pObject : pointer to object 18029 """ 18030 18031 _fl_set_xyplot_alphaxtics = cfuncproto( 18032 load_so_libforms(), "fl_set_xyplot_alphaxtics", 18033 None, [cty.POINTER(FL_OBJECT), STRING, STRING], 18034 """void fl_set_xyplot_alphaxtics(FL_OBJECT * ob, const char * m, 18035 const char * s) 18036 """) 18037 sm = convert_to_string(m) 18038 ss = convert_to_string(s) 18039 keep_elem_refs(pObject, m, s, sm, ss) 18040 _fl_set_xyplot_alphaxtics(pObject, sm, ss)
18041 18042
18043 -def fl_set_xyplot_alphaytics(pObject, m, s):
18044 """ 18045 fl_set_xyplot_alphaytics(pObject, m, s) 18046 18047 @param pObject : pointer to object 18048 """ 18049 18050 _fl_set_xyplot_alphaytics = cfuncproto( 18051 load_so_libforms(), "fl_set_xyplot_alphaytics", 18052 None, [cty.POINTER(FL_OBJECT), STRING, STRING], 18053 """void fl_set_xyplot_alphaytics(FL_OBJECT * ob, const char * m, 18054 const char * s) 18055 """) 18056 sm = convert_to_string(m) 18057 ss = convert_to_string(s) 18058 keep_elem_refs(pObject, m, s, sm, ss) 18059 _fl_set_xyplot_alphaytics(pObject, sm, ss)
18060 18061
18062 -def fl_set_xyplot_fixed_xaxis(pObject, lm, rm):
18063 """ 18064 fl_set_xyplot_fixed_xaxis(pObject, lm, rm) 18065 18066 @param pObject : pointer to object 18067 """ 18068 18069 _fl_set_xyplot_fixed_xaxis = cfuncproto( 18070 load_so_libforms(), "fl_set_xyplot_fixed_xaxis", 18071 None, [cty.POINTER(FL_OBJECT), STRING, STRING], 18072 """void fl_set_xyplot_fixed_xaxis(FL_OBJECT * ob, const char * lm, 18073 const char * rm) 18074 """) 18075 slm = convert_to_string(lm) 18076 srm = convert_to_string(rm) 18077 keep_elem_refs(pObject, lm, rm, slm, srm) 18078 _fl_set_xyplot_fixed_xaxis(pObject, slm, srm)
18079 18080
18081 -def fl_set_xyplot_fixed_yaxis(pObject, bm, tm):
18082 """ 18083 fl_set_xyplot_fixed_yaxis(pObject, bm, tm) 18084 18085 @param pObject : pointer to object 18086 """ 18087 18088 _fl_set_xyplot_fixed_yaxis = cfuncproto( 18089 load_so_libforms(), "fl_set_xyplot_fixed_yaxis", 18090 None, [cty.POINTER(FL_OBJECT), STRING, STRING], 18091 """void fl_set_xyplot_fixed_yaxis(FL_OBJECT * ob, const char * bm, 18092 const char * tm) 18093 """) 18094 sbm = convert_to_string(bm) 18095 stm = convert_to_string(tm) 18096 keep_elem_refs(pObject, bm, tm, sbm, stm) 18097 _fl_set_xyplot_fixed_yaxis(pObject, sbm, stm)
18098 18099
18100 -def fl_interpolate(wx, wy, nin, x, y, grid, ndeg):
18101 """ 18102 fl_interpolate(wx, wy, nin, x, y, grid, ndeg) -> num. 18103 """ 18104 18105 _fl_interpolate = cfuncproto( 18106 load_so_libforms(), "fl_interpolate", 18107 cty.c_int, [cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 18108 cty.c_int, cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 18109 cty.c_double, cty.c_int], 18110 """int fl_interpolate(const char * wx, const char * wy, int nin, 18111 float * x, float * y, double grid, int ndeg) 18112 """) 18113 inin = convert_to_int(nin) 18114 fgrid = convert_to_double(grid) 18115 indeg = convert_to_int(ndeg) 18116 keep_elem_refs(wx, wy, nin, x, y, grid, ndeg, inin, fgrid, indeg) 18117 retval = _fl_interpolate(wx, wy, inin, x, y, fgrid, indeg) 18118 return retval
18119 18120
18121 -def fl_spline_interpolate(wx, wy, nin, x, y, grid):
18122 """ 18123 fl_spline_interpolate(wx, wy, nin, x, y, grid) -> num. 18124 """ 18125 18126 _fl_spline_interpolate = cfuncproto( 18127 load_so_libforms(), "fl_spline_interpolate", 18128 cty.c_int, [cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 18129 cty.c_int, cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 18130 cty.c_double], 18131 """int fl_spline_interpolate(const char * wx, const char * wy, 18132 int nin, float * x, float * y, double grid) 18133 """) 18134 inin = convert_to_int(nin) 18135 fgrid = convert_to_double(grid) 18136 keep_elem_refs(wx, wy, nin, x, y, grid, inin, fgrid) 18137 retval = _fl_spline_interpolate(wx, wy, inin, x, y, fgrid) 18138 return retval
18139 18140 18141 FL_XYPLOT_SYMBOL = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_int, 18142 cty.POINTER(FL_POINT), cty.c_int, cty.c_int, cty.c_int) 18143
18144 -def fl_set_xyplot_symbol(pObject, idnum, py_XyPlotSymbol):
18145 """ 18146 fl_set_xyplot_symbol(pObject, idnum, py_XyPlotSymbol) -> xyplot_symbol func. 18147 18148 @param pObject : pointer to object 18149 """ 18150 18151 _fl_set_xyplot_symbol = cfuncproto( 18152 load_so_libforms(), "fl_set_xyplot_symbol", 18153 FL_XYPLOT_SYMBOL, [cty.POINTER(FL_OBJECT), cty.c_int, 18154 FL_XYPLOT_SYMBOL], 18155 """FL_XYPLOT_SYMBOL fl_set_xyplot_symbol(FL_OBJECT * ob, int id, 18156 FL_XYPLOT_SYMBOL symbol) 18157 """) 18158 iidnum = convert_to_int(idnum) 18159 c_XyPlotSymbol = FL_XYPLOT_SYMBOL(py_XyPlotSymbol) 18160 keep_cfunc_refs(c_XyPlotSymbol, py_XyPlotSymbol) 18161 keep_elem_refs(pObject, idnum, iidnum) 18162 retval = _fl_set_xyplot_symbol(pObject, iidnum, c_XyPlotSymbol) 18163 return retval
18164 18165
18166 -def fl_set_xyplot_mark_active(pObject, y):
18167 """ 18168 fl_set_xyplot_mark_active(pObject, y) -> num. 18169 18170 @param pObject : pointer to object 18171 """ 18172 18173 _fl_set_xyplot_mark_active = cfuncproto( 18174 load_so_libforms(), "fl_set_xyplot_mark_active", 18175 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 18176 """int fl_set_xyplot_mark_active(FL_OBJECT * ob, int y) 18177 """) 18178 iy = convert_to_int(y) 18179 keep_elem_refs(pObject, y, iy) 18180 retval = _fl_set_xyplot_mark_active(pObject, iy) 18181 return retval
18182 18183 18184 # the following (fl_fheight) etc. were never documented and were 18185 # removed from V0.89, but apparently this broke some applications that 18186 # were using them. Put them back in 10/22/00 18187
18188 -def fl_gc_():
18189 """ 18190 fl_gc_() -> gc 18191 """ 18192 18193 _fl_gc_ = cfuncproto( 18194 load_so_libforms(), "fl_gc_", 18195 GC, [], 18196 """GC fl_gc_() 18197 """) 18198 retval = _fl_gc_() 18199 return retval
18200 18201
18202 -def fl_textgc_():
18203 """ 18204 fl_textgc_() -> gc 18205 """ 18206 18207 _fl_textgc_ = cfuncproto( 18208 load_so_libforms(), "fl_textgc_", 18209 GC, [], 18210 """)GC fl_textgc_() 18211 """) 18212 retval = _fl_textgc_() 18213 return retval
18214 18215
18216 -def fl_fheight_():
18217 """ 18218 fl_fheight_() -> num. 18219 """ 18220 18221 _fl_fheight_ = cfuncproto( 18222 load_so_libforms(), "fl_fheight_", 18223 cty.c_int, [], 18224 """int fl_fheight_() 18225 """) 18226 retval = _fl_fheight_() 18227 return retval
18228 18229
18230 -def fl_fdesc_():
18231 """ 18232 fl_fdesc_() -> num. 18233 """ 18234 18235 _fl_fdesc_ = cfuncproto( 18236 load_so_libforms(), "fl_fdesc_", 18237 cty.c_int, [], 18238 """int fl_fdesc_() 18239 """) 18240 retval = _fl_fdesc_() 18241 return retval
18242 18243
18244 -def fl_cur_win_():
18245 """ 18246 fl_cur_win_() -> window 18247 """ 18248 18249 _fl_cur_win_ = cfuncproto( 18250 load_so_libforms(), "fl_cur_win_", 18251 Window, [], 18252 """Window fl_cur_win_() 18253 """) 18254 retval = _fl_cur_win_() 18255 return retval
18256 18257
18258 -def fl_cur_fs_():
18259 """ 18260 fl_cur_fs_() -> XFontStruct class 18261 """ 18262 18263 _fl_cur_fs_ = cfuncproto( 18264 load_so_libforms(), "fl_cur_fs_", 18265 cty.POINTER(XFontStruct), [], 18266 """XFontStruct * fl_cur_fs_() 18267 """) 18268 retval = _fl_cur_fs_() 18269 return retval
18270 18271 18272 # commented to prevent a SegmentationFault during installation --LK 18273 #fl_textgc = fl_textgc_() 18274 fl_textgc = fl_textgc_ 18275 #fl_gc = fl_gc_() 18276 fl_gc = fl_gc_ 18277 #fl_cur_win = fl_cur_win_() 18278 fl_cur_win = fl_cur_win_ 18279 #fl_fheight = fl_fheight_() 18280 fl_fheight = fl_fheight_ 18281 #fl_fdesc = fl_fdesc_() 18282 fl_fdesc = fl_fdesc_ 18283 #fl_cur_fs = fl_cur_fs_() 18284 fl_cur_fs = fl_cur_fs_ 18285 18286
18287 -def fl_display_():
18288 """ 18289 fl_display_() -> pDisplay 18290 """ 18291 18292 _fl_display_ = cfuncproto( 18293 load_so_libforms(), "fl_display_", 18294 cty.POINTER(Display), [], 18295 """Display * fl_display_() 18296 """) 18297 retval = _fl_display_() 18298 return retval
18299 18300 18301 18302 ######################### 18303 # flimage.h 18304 # Image related routines 18305 ######################### 18306 18307 # low-level, maybe unused in python --LK 18308 #def fl_safe_free(p): 18309 # if p: 18310 # fl_free(p) 18311 # p = None # UNSURE 18312
18313 -def FL_RGB2GRAY(r, g, b):
18314 return cty.c_uint((78 * (r) + 150 * (g) + 28 * (b)) >> 8)
18315 18316 18317 # if PCBITS is not 8, we need to apply the RGBmask 18318
18319 -def FL_IsRGB(pImage):
18320 return (pImage.contents.type == FL_IMAGE_RGB)
18321
18322 -def FL_IsPacked(pImage):
18323 return (pImage.contents.type == FL_IMAGE_PACKED)
18324 18325
18326 -def flimage_setup(pImageSetup):
18327 """ 18328 flimage_setup(pImageSetup) 18329 18330 @param pImageSetup : pointer to imagesetup struct 18331 """ 18332 18333 _flimage_setup = cfuncproto( 18334 load_so_libflimage(), "flimage_setup", 18335 None, [cty.POINTER(FLIMAGE_SETUP)], 18336 """void flimage_setup(FLIMAGE_SETUP * setup) 18337 """) 18338 keep_elem_refs(pImageSetup) 18339 _flimage_setup(pImageSetup)
18340 18341 18342 # basic IO routines 18343
18344 -def flimage_load(filename):
18345 """ 18346 flimage_load(filename) -> pImage 18347 18348 @param filename : name of file to load 18349 """ 18350 18351 _flimage_load = cfuncproto( 18352 load_so_libflimage(), "flimage_load", 18353 cty.POINTER(FL_IMAGE), [STRING], 18354 """FL_IMAGE * flimage_load(const char * file) 18355 """) 18356 sfilename = convert_to_string(filename) 18357 keep_elem_refs(filename, sfilename) 18358 retval = _flimage_load(sfilename) 18359 return retval
18360 18361
18362 -def flimage_read(pImage):
18363 """ 18364 flimage_read(pImage) -> pImage 18365 18366 @param pImage : pointer to image 18367 """ 18368 18369 _flimage_read = cfuncproto( 18370 load_so_libflimage(), "flimage_read", 18371 cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE)], 18372 """FL_IMAGE * flimage_read(FL_IMAGE * im) 18373 """) 18374 keep_elem_refs(pImage) 18375 retval = _flimage_read(pImage) 18376 return retval
18377 18378
18379 -def flimage_dump(pImage, p2, p3):
18380 """ 18381 flimage_dump(pImage, p2, p3) -> num. 18382 18383 @param pImage : pointer to image 18384 """ 18385 18386 _flimage_dump = cfuncproto( 18387 load_so_libflimage(), "flimage_dump", 18388 cty.c_int, [cty.POINTER(FL_IMAGE), STRING, STRING], 18389 """int flimage_dump(FL_IMAGE * p1, const char * p2, 18390 const char * p3) 18391 """) 18392 sp2 = convert_to_string(p2) 18393 sp3 = convert_to_string(p3) 18394 keep_elem_refs(pImage, p2, p3, sp2, sp3) 18395 retval = _flimage_dump(pImage, sp2, sp3) 18396 return retval
18397 18398
18399 -def flimage_close(pImage):
18400 """ 18401 flimage_close(pImage) -> num. 18402 18403 @param pImage : pointer to image 18404 """ 18405 18406 _flimage_close = cfuncproto( 18407 load_so_libflimage(), "flimage_close", 18408 cty.c_int, [cty.POINTER(FL_IMAGE)], 18409 """int flimage_close(FL_IMAGE * p1) 18410 """) 18411 keep_elem_refs(pImage) 18412 retval = _flimage_close(pImage) 18413 return retval
18414 18415
18416 -def flimage_alloc():
18417 """ 18418 flimage_alloc() -> pImage 18419 """ 18420 18421 _flimage_alloc = cfuncproto( 18422 load_so_libflimage(), "flimage_alloc", 18423 cty.POINTER(FL_IMAGE), [], 18424 """FL_IMAGE * flimage_alloc() 18425 """) 18426 retval = _flimage_alloc() 18427 return retval
18428 18429
18430 -def flimage_getmem(pImage):
18431 """ 18432 flimage_getmem(pImage) -> num. 18433 18434 @param pImage : pointer to image 18435 """ 18436 18437 _flimage_getmem = cfuncproto( 18438 load_so_libflimage(), "flimage_getmem", 18439 cty.c_int, [cty.POINTER(FL_IMAGE)], 18440 """int flimage_getmem(FL_IMAGE * p1) 18441 """) 18442 keep_elem_refs(pImage) 18443 retval = _flimage_getmem(pImage) 18444 return retval
18445 18446
18447 -def flimage_is_supported(fname):
18448 """ 18449 flimage_is_supported(fname) -> num. 18450 18451 @param fname : filename 18452 """ 18453 18454 _flimage_is_supported = cfuncproto( 18455 load_so_libflimage(), "flimage_is_supported", 18456 cty.c_int, [STRING], 18457 """int flimage_is_supported(const char * p1) 18458 """) 18459 sfname = convert_to_string(fname) 18460 keep_elem_refs(fname, sfname) 18461 retval = _flimage_is_supported(sfname) 18462 return retval
18463 18464
18465 -def flimage_description_via_filter(pImage, p2, p3, p4):
18466 """ 18467 flimage_description_via_filter(pImage, p2, p3, p4) -> num. 18468 18469 @param pImage : pointer to image 18470 """ 18471 18472 _flimage_description_via_filter = cfuncproto( 18473 load_so_libflimage(), "flimage_description_via_filter", 18474 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(STRING), STRING, 18475 cty.c_int], 18476 """int flimage_description_via_filter(FL_IMAGE * p1, 18477 const char * p2, const char * p3, int p4) 18478 """) 18479 sp3 = convert_to_string(p3) 18480 ip4 = convert_to_string(p4) 18481 keep_elem_refs(pImage, p2, p3, p4, sp3, ip4) 18482 retval = _flimage_description_via_filter(pImage, p2, sp3, ip4) 18483 return retval
18484 18485
18486 -def flimage_write_via_filter(pImage, p2, p3, p4):
18487 """ 18488 flimage_write_via_filter(pImage, p2, p3, p4) -> num. 18489 18490 @param pImage : pointer to image 18491 """ 18492 18493 _flimage_write_via_filter = cfuncproto( 18494 load_so_libflimage(), "flimage_write_via_filter", 18495 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(STRING), 18496 cty.POINTER(STRING), cty.c_int], 18497 """int flimage_write_via_filter(FL_IMAGE * p1, const char * p2, 18498 const char * p3, int p4) 18499 """) 18500 ip4 = convert_to_int(p4) 18501 keep_elem_refs(pImage, p2, p3, p4, ip4) 18502 retval = _flimage_write_via_filter(pImage, p2, p3, ip4) 18503 return retval
18504 18505
18506 -def flimage_free(pImage):
18507 """ 18508 flimage_free(pImage) -> num. 18509 18510 @param pImage : pointer to image 18511 """ 18512 18513 _flimage_free = cfuncproto( 18514 load_so_libflimage(), "flimage_free", 18515 cty.c_int, [cty.POINTER(FL_IMAGE)], 18516 """int flimage_free(FL_IMAGE * p1) 18517 """) 18518 keep_elem_refs(pImage) 18519 retval = _flimage_free(pImage) 18520 return retval
18521 18522
18523 -def flimage_display(pImage, win):
18524 """ 18525 flimage_display(pImage, win) -> num. 18526 18527 @param pImage : pointer to image 18528 @param win : window 18529 """ 18530 18531 _flimage_display = cfuncproto( 18532 load_so_libflimage(), "flimage_display", 18533 cty.c_int, [cty.POINTER(FL_IMAGE), Window], 18534 """int flimage_display(FL_IMAGE * p1, Window p2) 18535 """) 18536 ulwin = convert_to_Window(win) 18537 keep_elem_refs(pImage, win, ulwin) 18538 retval = _flimage_display(pImage, ulwin) 18539 return retval
18540 18541
18542 -def flimage_sdisplay(pImage, win):
18543 """ 18544 flimage_sdisplay(pImage, win) -> num. 18545 18546 @param pImage : pointer to image 18547 @param win : window 18548 """ 18549 18550 _flimage_sdisplay = cfuncproto( 18551 load_so_libflimage(), "flimage_sdisplay", 18552 cty.c_int, [cty.POINTER(FL_IMAGE), Window], 18553 """int flimage_sdisplay(FL_IMAGE * p1, Window p2) 18554 """) 18555 ulwin = convert_to_Window(win) 18556 keep_elem_refs(pImage, win, ulwin) 18557 retval = _flimage_sdisplay(pImage, ulwin) 18558 return retval
18559 18560
18561 -def flimage_convert(pImage, newtype, ncolors):
18562 """ 18563 flimage_convert(pImage, newtype, ncolors) -> num. 18564 18565 Convert an image to a new type. 18566 18567 @param pImage : pointer to image 18568 @param newtype : new type of flimage to convert to 18569 @param ncolors : number of colors 18570 """ 18571 18572 _flimage_convert = cfuncproto( 18573 load_so_libflimage(), "flimage_convert", 18574 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 18575 """int flimage_convert(FL_IMAGE * p1, int p2, int p3) 18576 """) 18577 inewtype2 = convert_to_int(newtype) 18578 incolors = convert_to_int(ncolors) 18579 keep_elem_refs(pImage, newtype, ncolors, inewtype, incolors) 18580 retval = _flimage_convert(pImage, inewtype, incolors) 18581 return retval
18582 18583
18584 -def flimage_type_name(flimagetype):
18585 """ 18586 flimage_type_name(flimagetype) -> name string 18587 18588 @param flimagetype : type of flimage 18589 """ 18590 18591 _flimage_type_name = cfuncproto( 18592 load_so_libflimage(), "flimage_type_name", 18593 STRING, [cty.c_int], 18594 """const char * flimage_type_name(int type) 18595 """) 18596 check_admitted_values(flimagetype, FLIMAGETYPE_list) 18597 iflimagetype = convert_to_int(flimagetype) 18598 keep_elem_refs(flimagetype, iflimagetype) 18599 retval = _flimage_type_name(iflimagetype) 18600 return retval
18601 18602
18603 -def flimage_add_text(pImage, text, length, style, size, txtcolr, bgcolr, tran, tx, ty, rot):
18604 """ 18605 flimage_add_text(pImage, text, length, style, size, txtcolr, bgcolr, tran, tx, ty, rot) -> num. 18606 18607 @param pImage : pointer to image 18608 """ 18609 18610 _flimage_add_text = cfuncproto( 18611 load_so_libflimage(), "flimage_add_text", 18612 cty.c_int, [cty.POINTER(FL_IMAGE), STRING, cty.c_int, cty.c_int, 18613 cty.c_int, cty.c_uint, cty.c_uint, cty.c_int, cty.c_double, 18614 cty.c_double, cty.c_int], 18615 """int flimage_add_text(FL_IMAGE * im, const char * str, int len, 18616 int style, int size, unsigned int tcol, unsigned int bcol, 18617 int tran, double tx, double ty, int rot) 18618 """) 18619 stext = convert_to_string(text) 18620 ilength = convert_to_int(length) 18621 istyle = convert_to_int(style) 18622 isize = convert_to_int(size) 18623 uitxtcol = convert_to_uint(txtcolr) 18624 uibgcol = convert_to_uint(bgcolr) 18625 itran = convert_to_int(tran) 18626 ftx = convert_to_double(tx) 18627 fty = convert_to_double(ty) 18628 irot = convert_to_int(rot) 18629 keep_elem_refs(pImage, text, length, style, size, txtcolr, bgcolr, tran, \ 18630 tx, ty, rot, stext, ilength, istyle, isize, uitxtcolr, \ 18631 uibgcolr, itran, ftx, fty, irot) 18632 retval = _flimage_add_text(pImage, stext, ilength, istyle, isize, uitxtcolr, \ 18633 uibgcolr, itran, ftx, fty, irot) 18634 return retval
18635 18636
18637 -def flimage_add_text_struct(pImage, pImageText):
18638 """ 18639 flimage_add_text_struct(pImage, pImageText) -> num. 18640 18641 @param pImage : pointer to image 18642 """ 18643 18644 _flimage_add_text_struct = cfuncproto( 18645 load_so_libflimage(), "flimage_add_text_struct", 18646 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(FLIMAGE_TEXT)], 18647 """int flimage_add_text_struct(FL_IMAGE * p1, const char * p2) 18648 """) 18649 keep_elem_refs(pImage, pImageText) 18650 retval = _flimage_add_text_struct(pImage, pImageText) 18651 return retval
18652 18653
18654 -def flimage_delete_all_text(pImage):
18655 """ 18656 flimage_delete_all_text(pImage) 18657 18658 @param pImage : pointer to image 18659 """ 18660 18661 _flimage_delete_all_text = cfuncproto( 18662 load_so_libflimage(), "flimage_delete_all_text", 18663 None, [cty.POINTER(FL_IMAGE)], 18664 """void flimage_delete_all_text(FL_IMAGE * p1) 18665 """) 18666 keep_elem_refs(pImage) 18667 _flimage_delete_all_text(pImage)
18668 18669
18670 -def flimage_add_marker(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11):
18671 """ 18672 flimage_add_marker(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11) -> num. 18673 18674 @param pImage : pointer to image 18675 """ 18676 18677 _flimage_add_marker = cfuncproto( 18678 load_so_libflimage(), "flimage_add_marker", 18679 cty.c_int, [cty.POINTER(FL_IMAGE), STRING, cty.c_double, 18680 cty.c_double, cty.c_double, cty.c_double, cty.c_int, cty.c_int, 18681 cty.c_int, cty.c_uint, cty.c_uint], 18682 """int flimage_add_marker(FL_IMAGE * p1, const char * p2, 18683 double p3, double p4, double p5, double p6, int p7, 18684 int p8, int p9, unsigned int p10, unsigned int p11) 18685 """) 18686 stext = convert_to_string(text) 18687 fp3 = convert_to_double(p3) 18688 fp4 = convert_to_double(p4) 18689 fp5 = convert_to_double(p5) 18690 fp6 = convert_to_double(p6) 18691 ip7 = convert_to_int(p7) 18692 ip8 = convert_to_int(p8) 18693 ip9 = convert_to_int(p9) 18694 uip10 = convert_to_uint(p10) 18695 uip11 = convert_to_uint(p11) 18696 keep_elem_refs(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11, 18697 stext, fp3, fp4, fp5, fp6, ip7, ip8, ip9, uip10, uip11) 18698 retval = _flimage_add_marker(pImage, stext, fp3, fp4, fp5, fp6, ip7, 18699 ip8, ip9, uip10, uip11) 18700 return retval
18701 18702
18703 -def flimage_add_marker_struct(pImage, pImageMarker):
18704 """ 18705 flimage_add_marker_struct(pImage, pImageMarker) -> num. 18706 18707 @param pImage : pointer to image 18708 """ 18709 18710 _flimage_add_marker_struct = cfuncproto( 18711 load_so_libflimage(), "flimage_add_marker_struct", 18712 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(FLIMAGE_MARKER)], 18713 """int flimage_add_marker_struct(FL_IMAGE * p1, const char * p2) 18714 """) 18715 keep_elem_refs(pImage, pImageMarker) 18716 retval = _flimage_add_marker_struct(pImage, pImageMarker) 18717 return retval
18718 18719
18720 -def flimage_define_marker(text1, pImageMarker, text2):
18721 """ flimage_define_marker(text1, pImageMarker, text2) -> num. 18722 """ 18723 18724 _flimage_define_marker = cfuncproto( 18725 load_so_libflimage(), "flimage_define_marker", 18726 cty.c_int, [STRING, cty.POINTER(FLIMAGE_MARKER), STRING], 18727 """int flimage_define_marker(const char *, void ( * ) 18728 (FLIMAGE_MARKER *), const char *) 18729 """) 18730 stext1 = convert_to_string(text1) 18731 stext2 = convert_to_string(text2) 18732 keep_elem_refs(text1, pImageMarker, text2, stext1, stext2) 18733 retval = _flimage_define_marker(stext1, pImageMarker, stext2) 18734 return retval
18735 18736
18737 -def flimage_delete_all_markers(pImage):
18738 """ 18739 flimage_delete_all_markers(pImage) 18740 18741 @param pImage : pointer to image 18742 """ 18743 18744 _flimage_delete_all_markers = cfuncproto( 18745 load_so_libflimage(), "flimage_delete_all_markers", 18746 None, [cty.POINTER(FL_IMAGE)], 18747 """void flimage_delete_all_markers(FL_IMAGE * p1) 18748 """) 18749 keep_elem_refs(pImage) 18750 _flimage_delete_all_markers(pImage)
18751 18752
18753 -def flimage_render_annotation(pImage, win):
18754 """ 18755 flimage_render_annotation(pImage, win) -> num. 18756 18757 @param pImage : pointer to image 18758 @param win : window 18759 """ 18760 18761 _flimage_render_annotation = cfuncproto( 18762 load_so_libflimage(), "flimage_render_annotation", 18763 cty.c_int, [cty.POINTER(FL_IMAGE), FL_WINDOW], 18764 """int flimage_render_annotation(FL_IMAGE * p1, FL_WINDOW p2) 18765 """) 18766 ulwin = convert_to_Window(win) 18767 keep_elem_refs(pImage, win, ulwin) 18768 retval = _flimage_render_annotation(pImage, ulwin) 18769 return retval
18770 18771
18772 -def flimage_error(pImage, text):
18773 """ 18774 flimage_error(pImage, text) 18775 18776 @param pImage : pointer to image 18777 """ 18778 18779 _flimage_error = cfuncproto( 18780 load_so_libflimage(), "flimage_error", 18781 None, [cty.POINTER(FL_IMAGE), STRING], 18782 """void flimage_error(FL_IMAGE * p1, const char * p2) 18783 """) 18784 stext = convert_to_Window(text) 18785 keep_elem_refs(pImage, text, stext) 18786 _flimage_error(pImage, stext)
18787 18788 18789 # built-in format supports 18790
18791 -def flimage_enable_pnm():
18792 """ 18793 flimage_enable_pnm() 18794 """ 18795 18796 _flimage_enable_pnm = cfuncproto( 18797 load_so_libflimage(), "flimage_enable_pnm", 18798 None, [], 18799 """void flimage_enable_pnm() 18800 """) 18801 _flimage_enable_pnm()
18802 18803
18804 -def flimage_set_fits_bits(p1):
18805 """ 18806 flimage_set_fits_bits(p1) -> num. 18807 """ 18808 18809 _flimage_set_fits_bits = cfuncproto( 18810 load_so_libflimage(), "flimage_set_fits_bits", 18811 cty.c_int, [cty.c_int], 18812 """int flimage_set_fits_bits(int p1) 18813 """) 18814 ip1 = convert_to_int(p1) 18815 keep_elem_refs(p1, ip1) 18816 retval = _flimage_set_fits_bits(ip1) 18817 return retval
18818 18819
18820 -def flimage_jpeg_output_options(pImageJpegOption):
18821 """ 18822 flimage_jpeg_output_options(pImageJpegOption) 18823 """ 18824 18825 _flimage_jpeg_output_options = cfuncproto( 18826 load_so_libflimage(), "flimage_jpeg_output_options", 18827 None, [cty.POINTER(FLIMAGE_JPEG_OPTION)], 18828 """void flimage_jpeg_output_options(FLIMAGE_JPEG_OPTION * p1) 18829 """) 18830 keep_elem_refs(pImageJpegOption) 18831 _flimage_jpeg_output_options(pImageJpegOption)
18832 18833
18834 -def flimage_pnm_output_options(p1):
18835 """ 18836 flimage_pnm_output_options(p1) 18837 """ 18838 18839 _flimage_pnm_output_options = cfuncproto( 18840 load_so_libflimage(), "flimage_pnm_output_options", 18841 None, [cty.c_int], 18842 """void flimage_pnm_output_options(int p1) 18843 """) 18844 ip1 = convert_to_int(p1) 18845 keep_elem_refs(p1, ip1) 18846 _flimage_pnm_output_options(ip1)
18847 18848
18849 -def flimage_gif_output_options(p1):
18850 """ 18851 flimage_gif_output_options(p1) 18852 """ 18853 18854 _flimage_gif_output_options = cfuncproto( 18855 load_so_libflimage(), "flimage_gif_output_options", 18856 None, [cty.c_int], 18857 """void flimage_gif_output_options(int p1) 18858 """) 18859 ip1 = convert_to_int(p1) 18860 keep_elem_refs(p1, ip1) 18861 _flimage_gif_output_options(ip1)
18862 18863
18864 -def flimage_ps_options():
18865 """ 18866 flimage_ps_options() -> pFlpsControl 18867 """ 18868 18869 _flimage_ps_options = cfuncproto( 18870 load_so_libflimage(), "flimage_ps_options", 18871 cty.POINTER(FLPS_CONTROL), [], 18872 """FLPS_CONTROL * flimage_ps_options() 18873 """) 18874 retval = _flimage_ps_options() 18875 return retval
18876 18877 18878 flimage_jpeg_options = flimage_jpeg_output_options 18879 flimage_pnm_options = flimage_pnm_output_options 18880 flimage_gif_options = flimage_gif_output_options 18881 18882
18883 -def flimage_get_number_of_formats():
18884 """ 18885 flimage_get_number_of_formats() -> num. 18886 """ 18887 18888 _flimage_get_number_of_formats = cfuncproto( 18889 load_so_libflimage(), "flimage_get_number_of_formats", 18890 cty.c_int, [], 18891 """int flimage_get_number_of_formats() 18892 """) 18893 retval = _flimage_get_number_of_formats() 18894 return retval
18895 18896
18897 -def flimage_get_format_info(p1):
18898 """ 18899 flimage_get_format_info(p1) -> ImageFormatInfo class instance 18900 """ 18901 18902 _flimage_get_format_info = cfuncproto( 18903 load_so_libflimage(), "flimage_get_format_info", 18904 cty.POINTER(FLIMAGE_FORMAT_INFO), [cty.c_int], 18905 """const char * flimage_get_format_info(int p1) 18906 """) 18907 ip1 = convert_to_int(p1) 18908 keep_elem_refs(p1, ip1) 18909 retval = _flimage_get_format_info(ip1) 18910 return retval
18911 18912
18913 -def fl_get_matrix(nrows, ncols, esize):
18914 """ 18915 fl_get_matrix(nrows, ncols, esize) -> ? 18916 18917 @param nrows : number of rows 18918 @param ncols : number of columns 18919 @param esize : size of matrix 18920 """ 18921 18922 _fl_get_matrix = cfuncproto( 18923 load_so_libflimage(), "fl_get_matrix", 18924 cty.c_void_p, [cty.c_int, cty.c_int, cty.c_uint], 18925 """void * fl_get_matrix(int p1, int p2, unsigned int p3) 18926 """) 18927 inrows = convert_to_int(nrows) 18928 incols = convert_to_int(ncols) 18929 uiesize = convert_to_uint(esize) 18930 keep_elem_refs(nrows, ncols, esize, inrows, incols, uiesize) 18931 retval = _fl_get_matrix(inrows, incols, uiesize) 18932 return retval
18933 18934
18935 -def fl_make_matrix(nrows, ncols, esize, mem):
18936 """ 18937 fl_make_matrix(nrows, ncols, esize, mem) -> ? 18938 18939 Makes a matrix out of a given piece of memory. 18940 18941 @param nrows : number of rows 18942 @param ncols : number of columns 18943 @param esize : size of matrix 18944 @param mem : memory 18945 """ 18946 18947 _fl_make_matrix = cfuncproto( 18948 load_so_libflimage(), "fl_make_matrix", 18949 cty.c_void_p, [cty.c_int, cty.c_int, cty.c_uint, cty.c_void_p], 18950 """void * fl_make_matrix(int p1, int p2, unsigned int p3, 18951 void * p4) 18952 """) 18953 inrows = convert_to_int(nrows) 18954 incols = convert_to_int(ncols) 18955 uiesize = convert_to_uint(esize) 18956 pmem = cty.cast(mem, cty.c_void_p) 18957 keep_elem_refs(nrows, ncols, esize, mem, inrows, incols, uiesize, pmem) 18958 retval = _fl_make_matrix(inrows, incols, uiesize, pmem) 18959 return retval
18960 18961
18962 -def fl_free_matrix(mtrx):
18963 """ 18964 fl_free_matrix(mtrx) 18965 """ 18966 18967 _fl_free_matrix = cfuncproto( 18968 load_so_libflimage(), "fl_free_matrix", 18969 None, [cty.c_void_p], 18970 """void fl_free_matrix(void * p1) 18971 """) 18972 pmtrx = cty.cast(mtrx, cty.c_void_p) 18973 keep_elem_refs(mtrx, pmtrx) 18974 _fl_free_matrix(pmtrx)
18975 18976 18977 # This function is retained for compatibility reasons only. 18978 # It returns 1 always.
18979 -def fl_init_RGBdatabase(text):
18980 """ 18981 fl_init_RGBdatabase(text) -> num. 18982 """ 18983 18984 _fl_init_RGBdatabase = cfuncproto( 18985 load_so_libflimage(), "fl_init_RGBdatabase", 18986 cty.c_int, [STRING], 18987 """int fl_init_RGBdatabase(const char * p1) 18988 """) 18989 stext = convert_to_string(text) 18990 keep_elem_refs(text, stext) 18991 retval = _fl_init_RGBdatabase(stext) 18992 return retval
18993 18994
18995 -def fl_lookup_RGBcolor(text, p2, p3, p4):
18996 """ 18997 fl_lookup_RGBcolor(text, p2, p3, p4) -> num. 18998 """ 18999 19000 _fl_lookup_RGBcolor = cfuncproto( 19001 load_so_libflimage(), "fl_lookup_RGBcolor", 19002 cty.c_int, [STRING, cty.POINTER(cty.c_int), \ 19003 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 19004 """int fl_lookup_RGBcolor(const char * p1, int * p2, 19005 int * p3, int * p4) 19006 """) 19007 stext = convert_to_string(text) 19008 keep_elem_refs(text, p2, p3, p4) 19009 retval = _fl_lookup_RGBcolor(stext, p2, p3, p4) 19010 return retval
19011 19012 19013 FLIMAGE_Identify = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FILE)) 19014 FLIMAGE_Description = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 19015 FLIMAGE_Read_Pixels = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 19016 FLIMAGE_Write_Image = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 19017
19018 -def flimage_add_format(formalname, shortname, extension, flimagetype, \ 19019 py_ImageIdentify, py_ImageDescription, \ 19020 py_ImageReadPixels, py_ImageWriteImage):
19021 """ flimage_add_format(formalname, shortname, extension, flimagetype, 19022 py_ImageIdentify, py_ImageDescription, py_ImageReadPixels, 19023 py_ImageWriteImage) -> num. 19024 """ 19025 19026 _flimage_add_format = cfuncproto( 19027 load_so_libflimage(), "flimage_add_format", 19028 cty.c_int, [STRING, STRING, STRING, cty.c_int, FLIMAGE_Identify, 19029 FLIMAGE_Description, FLIMAGE_Read_Pixels, FLIMAGE_Write_Image], 19030 """int flimage_add_format(const char * p1, const char * p2, 19031 const char * p3, int p4, FLIMAGE_Identify p5, 19032 FLIMAGE_Description p6, FLIMAGE_Read_Pixels p7, 19033 FLIMAGE_Write_Image p8) 19034 """) 19035 check_admitted_values(flimagetype, FLIMAGETYPE_list) 19036 sformalname = convert_to_string(formalname) 19037 sshortname = convert_to_string(shortname) 19038 sextension = convert_to_string(extension) 19039 iflimagetype = convert_to_int(flimagetype) 19040 c_ImageIdentify = FLIMAGE_Identify(py_ImageIdentify) 19041 c_ImageDescription = FLIMAGE_Description(py_ImageDescription) 19042 c_ImageReadPixels = FLIMAGE_Read_Pixels(py_ImageReadPixels) 19043 c_ImageWriteImage = FLIMAGE_Write_Image(py_ImageWriteImage) 19044 keep_cfunc_refs(c_ImageIdentify, py_ImageIdentify, c_ImageDescription, \ 19045 py_ImageDescription, c_ImageReadPixels, py_ImageReadPixels, 19046 c_ImageWriteImage, py_ImageWriteImage) 19047 keep_elem_refs(formalname, shortname, extension, flimagetype, \ 19048 sformalname, sshortname, sextension, iflimagetype) 19049 retval = _flimage_add_format(sformalname, sshortname, sextension, \ 19050 flimagetype, c_ImageIdentify, c_ImageDescription, \ 19051 c_ImageReadPixels, c_ImageWriteImage) 19052 return retval
19053 19054
19055 -def flimage_set_annotation_support(p1, p2):
19056 """ flimage_set_annotation_support(p1, p2) 19057 """ 19058 19059 _flimage_set_annotation_support = cfuncproto( 19060 load_so_libflimage(), "flimage_set_annotation_support", 19061 None, [cty.c_int, cty.c_int], 19062 """void flimage_set_annotation_support(int p1, int p2) 19063 """) 19064 ip1 = convert_to_int(p1) 19065 ip2 = convert_to_int(p2) 19066 keep_elem_refs(p1, p2, ip1, ip2) 19067 _flimage_set_annotation_support(ip1, ip2)
19068 19069
19070 -def flimage_getcolormap(pImage):
19071 """ 19072 flimage_getcolormap(pImage) -> num. 19073 19074 @param pImage : pointer to image 19075 """ 19076 19077 _flimage_getcolormap = cfuncproto( 19078 load_so_libflimage(), "flimage_getcolormap", 19079 cty.c_int, [cty.POINTER(FL_IMAGE)], 19080 """int flimage_getcolormap(FL_IMAGE * p1) 19081 """) 19082 keep_elem_refs(pImage) 19083 retval = _flimage_getcolormap(pImage) 19084 return retval
19085 19086
19087 -def fl_select_mediancut_quantizer():
19088 """ 19089 fl_select_mediancut_quantizer() 19090 """ 19091 19092 _fl_select_mediancut_quantizer = cfuncproto( 19093 load_so_libflimage(), "fl_select_mediancut_quantizer", 19094 None, [], 19095 """void fl_select_mediancut_quantizer() 19096 """) 19097 _fl_select_mediancut_quantizer()
19098 19099 19100 # simple image processing routines 19101
19102 -def flimage_convolve(pImage, p2, p3, p4):
19103 """ 19104 flimage_convolve(pImage, p2, p3, p4) -> num. 19105 19106 @param pImage : pointer to image 19107 """ 19108 19109 _flimage_convolve = cfuncproto( 19110 load_so_libflimage(), "flimage_convolve", 19111 cty.c_int, [cty.POINTER(FL_IMAGE), 19112 cty.POINTER(cty.POINTER(cty.c_int)), cty.c_int, cty.c_int], 19113 """int flimage_convolve(FL_IMAGE * p1, int * * p2, int p3, 19114 int p4) 19115 """) 19116 ip3 = convert_to_int(p3) 19117 ip4 = convert_to_int(p4) 19118 keep_elem_refs(pImage, p2, p3, p4, ip3, ip4) 19119 retval = _flimage_convolve(pImage, p2, ip3, ip4) 19120 return retval
19121 19122
19123 -def flimage_convolvea(pImage, p2, p3, p4):
19124 """ 19125 flimage_convolvea(pImage, p2, p3, p4) -> num. 19126 19127 @param pImage : pointer to image 19128 """ 19129 19130 _flimage_convolvea = cfuncproto( 19131 load_so_libflimage(), "flimage_convolvea", 19132 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_int), 19133 cty.c_int, cty.c_int], 19134 """int flimage_convolvea(FL_IMAGE * p1, int * p2, int p3, int p4) 19135 """) 19136 keep_elem_refs(pImage, p2, p3, p4) 19137 retval = _flimage_convolvea(pImage, p2, p3, p4) 19138 return retval
19139 19140
19141 -def flimage_tint(pImage, p2, p3):
19142 """ 19143 flimage_tint(pImage, p2, p3) -> num. 19144 19145 @param pImage : pointer to image 19146 """ 19147 19148 _flimage_tint = cfuncproto( 19149 load_so_libflimage(), "flimage_tint", 19150 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, cty.c_double], 19151 """int flimage_tint(FL_IMAGE * p1, unsigned int p2, double p3) 19152 """) 19153 keep_elem_refs(pImage, p2, p3) 19154 retval = _flimage_tint(pImage, p2, p3) 19155 return retval
19156 19157
19158 -def flimage_rotate(pImage, p2, p3):
19159 """ 19160 flimage_rotate(pImage, p2, p3) -> num. 19161 19162 @param pImage : pointer to image 19163 """ 19164 19165 _flimage_rotate = cfuncproto( 19166 load_so_libflimage(), "flimage_rotate", 19167 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 19168 """int flimage_rotate(FL_IMAGE * p1, int p2, int p3) 19169 """) 19170 ip2 = convert_to_int(p2) 19171 ip3 = convert_to_int(p3) 19172 keep_elem_refs(pImage, p2, p3, ip2, ip3) 19173 retval = _flimage_rotate(pImage, ip2, ip3) 19174 return retval
19175 19176
19177 -def flimage_flip(pImage, p2):
19178 """ 19179 flimage_flip(pImage, p2) -> num. 19180 19181 @param pImage : pointer to image 19182 """ 19183 19184 _flimage_flip = cfuncproto( 19185 load_so_libflimage(), "flimage_flip", 19186 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int], 19187 """int flimage_flip(FL_IMAGE * p1, int p2) 19188 """) 19189 ip2 = convert_to_int(p2) 19190 keep_elem_refs(pImage, p2, ip2) 19191 retval = _flimage_flip(pImage, ip2) 19192 return retval
19193 19194
19195 -def flimage_scale(pImage, p2, p3, p4):
19196 """ 19197 flimage_scale(pImage, p2, p3, p4) -> num. 19198 19199 @param pImage : pointer to image 19200 """ 19201 19202 _flimage_scale = cfuncproto( 19203 load_so_libflimage(), "flimage_scale", 19204 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 19205 cty.c_int], 19206 """int flimage_scale(FL_IMAGE * p1, int p2, int p3, int p4) 19207 """) 19208 ip2 = convert_to_int(p2) 19209 ip3 = convert_to_int(p3) 19210 ip4 = convert_to_int(p4) 19211 keep_elem_refs(pImage, p2, p3, p4, ip2, ip3, ip4) 19212 retval = _flimage_scale(pImage, ip2, ip3, ip4) 19213 return retval
19214 19215
19216 -def flimage_warp(pImage, p2, p3, p4, p5):
19217 """ 19218 flimage_warp(pImage, p2, p3, p4, p5) -> num. 19219 19220 @param pImage : pointer to image 19221 """ 19222 19223 _flimage_warp = cfuncproto( 19224 load_so_libflimage(), "flimage_warp", 19225 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_float * 2), 19226 cty.c_int, cty.c_int, cty.c_int], 19227 """int flimage_warp(FL_IMAGE * p1, float * p2, int p3, int p4, 19228 int p5) 19229 """) 19230 ip3 = convert_to_int(p3) 19231 ip4 = convert_to_int(p4) 19232 ip5 = convert_to_int(p5) 19233 keep_elem_refs(pImage, p2, p3, p4, p5, ip3, ip4, ip5) 19234 retval = _flimage_warp(pImage, p2, ip3, ip4, ip5) 19235 return retval
19236 19237
19238 -def flimage_autocrop(pImage, p2):
19239 """ 19240 flimage_autocrop(pImage, p2) -> num. 19241 19242 @param pImage : pointer to image 19243 """ 19244 19245 _flimage_autocrop = cfuncproto( 19246 load_so_libflimage(), "flimage_autocrop", 19247 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint], 19248 """int flimage_autocrop(FL_IMAGE * p1, unsigned int p2) 19249 """) 19250 uip2 = convert_to_uint(p2) 19251 keep_elem_refs(pImage, p2, uip2) 19252 retval = _flimage_autocrop(pImage, uip2) 19253 return retval
19254 19255 19256 #def flimage_get_autocrop(pImage, bk, xl, yt, xr, yb) *API change*
19257 -def flimage_get_autocrop(pImage, bk):
19258 """ flimage_get_autocrop(pImage, bk) -> num., xl, yt, xr, yb 19259 19260 @param pImage : pointer to image 19261 """ 19262 19263 _flimage_get_autocrop = cfuncproto( 19264 load_so_libflimage(), "flimage_get_autocrop", 19265 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, 19266 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 19267 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 19268 """int flimage_get_autocrop(FL_IMAGE * p1, unsigned int p2, 19269 int * p3, int * p4, int * p5, int * p6) 19270 """) 19271 uibk = convert_to_uint(bk) 19272 xl, pxl = make_int_and_pointer() 19273 yt, pyt = make_int_and_pointer() 19274 xr, pxr = make_int_and_pointer() 19275 yb, pyb = make_int_and_pointer() 19276 keep_elem_refs(pImage, bk, uibk, xl, pxl, yt, pyt, xr, pxr, yb, pyb) 19277 retval = _flimage_get_autocrop(pImage, uibk, pxl, pyt, pxr, pyb) 19278 return retval, xl, yt, xr, yb
19279 19280
19281 -def flimage_crop(pImage, p2, p3, p4, p5):
19282 """ 19283 flimage_crop(pImage, p2, p3, p4, p5) -> num. 19284 19285 @param pImage : pointer to image 19286 """ 19287 19288 _flimage_crop = cfuncproto( 19289 load_so_libflimage(), "flimage_crop", 19290 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 19291 cty.c_int, cty.c_int], 19292 """int flimage_crop(FL_IMAGE * p1, int p2, int p3, 19293 int p4, int p5) 19294 """) 19295 ip2 = convert_to_int(p2) 19296 ip3 = convert_to_int(p3) 19297 ip4 = convert_to_int(p4) 19298 ip5 = convert_to_int(p5) 19299 keep_elem_refs(pImage, p2, p3, p4, p5, ip2, ip3, ip4, ip5) 19300 retval = _flimage_crop(pImage, ip2, ip3, ip4, ip5) 19301 return retval
19302 19303
19304 -def flimage_replace_pixel(pImage, p2, p3):
19305 """ 19306 flimage_replace_pixel(pImage, p2, p3) -> num. 19307 19308 @param pImage : pointer to image 19309 """ 19310 19311 _flimage_replace_pixel = cfuncproto( 19312 load_so_libflimage(), "flimage_replace_pixel", 19313 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, cty.c_uint], 19314 """int flimage_replace_pixel(FL_IMAGE * p1, unsigned int p2, 19315 unsigned int p3) 19316 """) 19317 uip2 = convert_to_uint(p2) 19318 uip3 = convert_to_uint(p3) 19319 keep_elem_refs(pImage, p2, p3, uip2, uip3) 19320 retval = _flimage_replace_pixel(pImage, uip2, uip3) 19321 return retval
19322 19323
19324 -def flimage_transform_pixels(pImage, red, green, blue):
19325 """ 19326 flimage_transform_pixels(pImage, red, green, blue) -> num. 19327 19328 @param pImage : pointer to image 19329 """ 19330 19331 _flimage_transform_pixels = cfuncproto( 19332 load_so_libflimage(), "flimage_transform_pixels", 19333 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_int), 19334 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 19335 """int flimage_transform_pixels(FL_IMAGE * p1, int * p2, 19336 int * p3, int * p4) 19337 """) 19338 pred = cty.cast(red, cty.POINTER(cty.c_int)) 19339 pgreen = cty.cast(green, cty.POINTER(cty.c_int)) 19340 pblue = cty.cast(blue, cty.POINTER(cty.c_int)) 19341 keep_elem_refs(pImage, red, green, blue, pred, pgreen, pblue) 19342 retval = _flimage_transform_pixels(pImage, pred, pgreen, pblue) 19343 return retval
19344 19345
19346 -def flimage_windowlevel(pImage, p2, p3):
19347 """ 19348 flimage_windowlevel(pImage, p2, p3) -> num. 19349 19350 @param pImage : pointer to image 19351 """ 19352 19353 _flimage_windowlevel = cfuncproto( 19354 load_so_libflimage(), "flimage_windowlevel", 19355 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 19356 """int flimage_windowlevel(FL_IMAGE * p1, int p2, int p3) 19357 """) 19358 ip2 = convert_to_int(p2) 19359 ip3 = convert_to_int(p3) 19360 keep_elem_refs(pImage, p2, p3, ip2, ip3) 19361 retval = _flimage_windowlevel(pImage, ip2, ip3) 19362 return retval
19363 19364
19365 -def flimage_enhance(pImage, p2):
19366 """ 19367 flimage_enhance(pImage, p2) -> num. 19368 19369 @param pImage : pointer to image 19370 """ 19371 19372 _flimage_enhance = cfuncproto( 19373 load_so_libflimage(), "flimage_enhance", 19374 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int], 19375 """int flimage_enhance(FL_IMAGE * p1, int p2) 19376 """) 19377 ip2 = convert_to_int(p2) 19378 keep_elem_refs(pImage, p2, ip2) 19379 retval = _flimage_enhance(pImage, ip2) 19380 return retval
19381 19382
19383 -def flimage_from_pixmap(pImage, pixmap):
19384 """ 19385 flimage_from_pixmap(pImage, pixmap) -> num. 19386 19387 @param pImage : pointer to image 19388 @param pixmap : pixmap value 19389 """ 19390 19391 _flimage_from_pixmap = cfuncproto( 19392 load_so_libflimage(), "flimage_from_pixmap", 19393 cty.c_int, [cty.POINTER(FL_IMAGE), Pixmap], 19394 """int flimage_from_pixmap(FL_IMAGE * p1, Pixmap p2) 19395 """) 19396 ulpixmap = convert_to_Pixmap(pixmap) 19397 keep_elem_refs(pImage, pixmap, ulpixmap) 19398 retval = _flimage_from_pixmap(pImage, ulpixmap) 19399 return retval
19400 19401
19402 -def flimage_to_pixmap(pImage, win):
19403 """ 19404 flimage_to_pixmap(pImage, win) -> pixmap 19405 19406 @param pImage : pointer to image 19407 @param win : window id 19408 """ 19409 19410 _flimage_to_pixmap = cfuncproto( 19411 load_so_libflimage(), "flimage_to_pixmap", 19412 Pixmap, [cty.POINTER(FL_IMAGE), FL_WINDOW], 19413 """Pixmap flimage_to_pixmap(FL_IMAGE * p1, FL_WINDOW p2) 19414 """) 19415 ulwin = convert_to_Window(win) 19416 keep_elem_refs(pImage, win, ulwin) 19417 retval = _flimage_to_pixmap(pImage, ulwin) 19418 return retval
19419 19420
19421 -def flimage_dup(pImage):
19422 """ flimage_dup(pImage) -> pImage 19423 19424 @param pImage : pointer to image 19425 """ 19426 19427 _flimage_dup = cfuncproto( 19428 load_so_libflimage(), "flimage_dup", 19429 cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE)], 19430 """FL_IMAGE * flimage_dup(FL_IMAGE * p1) 19431 """) 19432 keep_elem_refs(pImage) 19433 retval = _flimage_dup(pImage) 19434 return retval
19435 19436 19437 # Miscellaneous prototypes 19438
19439 -def fl_get_submatrix(inmtrx, rows, cols, r1, c1, rs, cs, esize):
19440 """ fl_get_submatrix(inmtrx, rows, cols, r1, c1, rs, cs, esize) -> ? 19441 """ 19442 19443 _fl_get_submatrix = cfuncproto( 19444 load_so_libflimage(), "fl_get_submatrix", 19445 cty.c_void_p, [cty.c_void_p, cty.c_int, cty.c_int, cty.c_int, 19446 cty.c_int, cty.c_int, cty.c_int, cty.c_uint], 19447 """void * fl_get_submatrix(void * p1, int p2, int p3, int p4, 19448 int p5, int p6, int p7, unsigned int p8) 19449 """) 19450 pinmtrx = cty.cast(inmtrx, cty.c_void_p) 19451 irows = convert_to_int(rows) 19452 icols = convert_to_int(cols) 19453 ir1 = convert_to_int(r1) 19454 ic1 = convert_to_int(c1) 19455 irs = convert_to_int(rs) 19456 ics = convert_to_int(cs) 19457 uiesize = convert_to_uint(esize) 19458 keep_elem_refs(inmtrx, rows, cols, r1, c1, rs, cs, esize, pinmtrx, \ 19459 irows, icols, ir1, ic1, irs, ics, uiesize) 19460 retval = _fl_get_submatrix(pinmtrx, irows, icols, ir1, ic1, irs, ics, \ 19461 uiesize) 19462 return retval
19463 19464
19465 -def fl_j2pass_quantize_packed(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage):
19466 """ fl_j2pass_quantize_packed(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage) -> num. 19467 """ 19468 19469 _fl_j2pass_quantize_packed = cfuncproto( 19470 load_so_libflimage(), "fl_j2pass_quantize_packed", 19471 cty.c_int, [cty.POINTER(cty.POINTER(cty.c_uint)), cty.c_int, 19472 cty.c_int, cty.c_int, cty.POINTER(cty.POINTER(cty.c_ushort)), 19473 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 19474 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 19475 cty.POINTER(FL_IMAGE)], 19476 """int fl_j2pass_quantize_packed(unsigned int * * p1, int p2, 19477 int p3, int p4, short unsigned int * * p5, int * p6, 19478 int * p7, int * p8, int * p9, FL_IMAGE * p10) 19479 """) 19480 ip2 = convert_to_int(p2) 19481 ip3 = convert_to_int(p3) 19482 ip4 = convert_to_int(p4) 19483 keep_elem_refs(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage, ip2, ip3, ip4) 19484 retval = _fl_j2pass_quantize_packed(p1, ip2, ip3, ip4, p5, p6, p7, p8, \ 19485 p9, pImage) 19486 return retval
19487 19488
19489 -def fl_j2pass_quantize_rgb(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage):
19490 """ fl_j2pass_quantize_rgb(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage) -> num. 19491 """ 19492 19493 _fl_j2pass_quantize_rgb = cfuncproto( 19494 load_so_libflimage(), "fl_j2pass_quantize_rgb", 19495 cty.c_int, [cty.POINTER(cty.POINTER(cty.c_ubyte)), 19496 cty.POINTER(cty.POINTER(cty.c_ubyte)), 19497 cty.POINTER(cty.POINTER(cty.c_ubyte)), cty.c_int, cty.c_int, 19498 cty.c_int, cty.POINTER(cty.POINTER(cty.c_ushort)), 19499 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 19500 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 19501 cty.POINTER(FL_IMAGE)], 19502 """int fl_j2pass_quantize_rgb(unsigned char * * p1, 19503 unsigned char * * p2, unsigned char * * p3, int p4, int p5, 19504 int p6, short unsigned int * * p7, int * p8, int * p9, 19505 int * p10, int * p11, FL_IMAGE * p12) 19506 """) 19507 ip4 = convert_to_int(p4) 19508 ip5 = convert_to_int(p5) 19509 ip6 = convert_to_int(p6) 19510 keep_elem_refs(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage, 19511 ip4, ip5, ip6) 19512 retval = _fl_j2pass_quantize_rgb(p1, p2, p3, ip4, ip5, ip6, p7, p8, p9, \ 19513 p10, p11, pImage) 19514 return retval
19515 19516
19517 -def fl_make_submatrix(in_, rows, cols, r1, c1, rs, cs, esize):
19518 """ fl_make_submatrix(in_, rows, cols, r1, c1, rs, cs, esize) -> ? 19519 """ 19520 19521 _fl_make_submatrix = cfuncproto( 19522 load_so_libflimage(), "fl_make_submatrix", 19523 cty.c_void_p, [cty.c_void_p, cty.c_int, cty.c_int, cty.c_int, 19524 cty.c_int, cty.c_int, cty.c_int, cty.c_uint], 19525 """void * fl_make_submatrix(void * p1, int p2, int p3, int p4, 19526 int p5, int p6, int p7, unsigned int p8) 19527 """) 19528 irows = convert_to_int(rows) 19529 icols = convert_to_int(cols) 19530 ir1 = convert_to_int(r1) 19531 ic1 = convert_to_int(c1) 19532 irs = convert_to_int(rs) 19533 ics = convert_to_int(cs) 19534 uiesize = convert_to_uint(esize) 19535 keep_elem_refs(in_, rows, cols, r1, c1, rs, cs, esize, irows, icols, \ 19536 ir1, ic1, irs, ics, uiesize) 19537 retval = _fl_make_submatrix(in_, irows, icols, ir1, ic1, irs, ics, \ 19538 uiesize) 19539 return retval
19540 19541
19542 -def fl_pack_bits(p1, p2, p3):
19543 """ fl_pack_bits(p1, p2, p3) 19544 """ 19545 19546 _fl_pack_bits = cfuncproto( 19547 load_so_libflimage(), "fl_pack_bits", 19548 None, [cty.POINTER(cty.c_ubyte), cty.POINTER(cty.c_ushort), 19549 cty.c_int], 19550 """void fl_pack_bits(unsigned char * p1, short unsigned int * p2, 19551 int p3) 19552 """) 19553 ip3 = convert_to_int(p3) 19554 keep_elem_refs(p1, p2, p3, ip3) 19555 _fl_pack_bits(p1, p2, ip3)
19556 19557
19558 -def fl_unpack_bits(p1, p2, p3):
19559 """ fl_unpack_bits(p1, p2, p3) 19560 """ 19561 19562 _fl_unpack_bits = cfuncproto( 19563 load_so_libflimage(), "fl_unpack_bits", 19564 None, [cty.POINTER(cty.c_ushort), cty.POINTER(cty.c_ubyte), 19565 cty.c_int], 19566 """void fl_unpack_bits(short unsigned int * p1, 19567 unsigned char * p2, int p3) 19568 """) 19569 ip3 = convert_to_int(p3) 19570 keep_elem_refs(p1, p2, p3, ip3) 19571 _fl_unpack_bits(p1, p2, ip3)
19572 19573
19574 -def fl_value_to_bits(val):
19575 """ 19576 fl_value_to_bits(val) -> num. 19577 19578 @param val : value to convert to bits 19579 """ 19580 19581 _fl_value_to_bits = cfuncproto( 19582 load_so_libflimage(), "fl_value_to_bits", 19583 cty.c_uint, [cty.c_uint], 19584 """unsigned int fl_value_to_bits(unsigned int p1) 19585 """) 19586 uival = convert_to_uint(val) 19587 keep_elem_refs(val, uival) 19588 retval = _fl_value_to_bits(uival) 19589 return retval
19590 19591
19592 -def flimage_add_comments(pImage, p2, p3):
19593 """ 19594 flimage_add_comments(pImage, p2, p3) 19595 19596 @param pImage : pointer to image 19597 """ 19598 19599 _flimage_add_comments = cfuncproto( 19600 load_so_libflimage(), "flimage_add_comments", 19601 None, [cty.POINTER(FL_IMAGE), STRING, cty.c_int], 19602 """void flimage_add_comments(FL_IMAGE * p1, const char * p2, 19603 int p3) 19604 """) 19605 sp2 = convert_to_string(p2) 19606 ip3 = convert_to_int(p3) 19607 keep_elem_refs(pImage, p2, p3, sp2, ip3) 19608 _flimage_add_comments(pImage, sp2, ip3)
19609 19610
19611 -def flimage_color_to_pixel(pImage, p2, p3, p4, p5):
19612 """ 19613 flimage_color_to_pixel(pImage, p2, p3, p4, p5) -> num. 19614 19615 @param pImage : pointer to image 19616 """ 19617 19618 _flimage_color_to_pixel = cfuncproto( 19619 load_so_libflimage(), "flimage_color_to_pixel", 19620 cty.c_ulong, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 19621 cty.c_int, cty.POINTER(cty.c_int)], 19622 """)long unsigned int flimage_color_to_pixel(FL_IMAGE * p1, 19623 int p2, int p3, int p4, int * p5) 19624 """) 19625 ip2 = convert_to_int(p2) 19626 ip3 = convert_to_int(p3) 19627 ip4 = convert_to_int(p4) 19628 keep_elem_refs(pImage, p2, p3, p4, p5, ip2, ip3, ip4) 19629 retval = _flimage_color_to_pixel(pImage, ip2, ip3, ip4, p5) 19630 return retval
19631 19632
19633 -def flimage_combine(pImage1, pImage2, alpha):
19634 """ flimage_combine(pImage1, pImage2, alpha) -> pImage 19635 19636 @param pImage1 : pointer to first image to combine 19637 @param pImage2 : pointer to second image to combine 19638 @param alpha : alpha level? 19639 """ 19640 19641 _flimage_combine = cfuncproto( 19642 load_so_libflimage(), "flimage_combine", 19643 cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE), 19644 cty.POINTER(FL_IMAGE), cty.c_double], 19645 """FL_IMAGE * flimage_combine(FL_IMAGE * p1, FL_IMAGE * p2, 19646 double p3) 19647 """) 19648 falpha = convert_to_double(alpha) 19649 keep_elem_refs(pImage1, pImage2, alpha, falpha) 19650 retval = _flimage_combine(pImage1, pImage2, falpha) 19651 return retval
19652 19653
19654 -def flimage_display_markers(pImage):
19655 """ 19656 flimage_display_markers(pImage) 19657 19658 @param pImage : pointer to image 19659 """ 19660 19661 _flimage_display_markers = cfuncproto( 19662 load_so_libflimage(), "flimage_display_markers", 19663 None, [cty.POINTER(FL_IMAGE)], 19664 """void flimage_display_markers(FL_IMAGE * p1) 19665 """) 19666 keep_elem_refs(pImage) 19667 _flimage_display_markers(pImage)
19668 19669
19670 -def flimage_dup_(pImage, p2):
19671 """ 19672 flimage_dup_(pImage, p2) -> pImage 19673 19674 @param pImage : pointer to image 19675 """ 19676 19677 _flimage_dup_ = cfuncproto( 19678 load_so_libflimage(), "flimage_dup_", 19679 cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE), cty.c_int], 19680 """FL_IMAGE * flimage_dup_(FL_IMAGE * p1, int p2) 19681 """) 19682 ip2 = convert_to_int(p2) 19683 keep_elem_refs(pImage, p2, ip2) 19684 retval = _flimage_dup_(pImage, ip2) 19685 return retval
19686 19687
19688 -def flimage_enable_bmp():
19689 """ 19690 flimage_enable_bmp() 19691 """ 19692 19693 _flimage_enable_bmp = cfuncproto( 19694 load_so_libflimage(), "flimage_enable_bmp", 19695 None, [], 19696 """void flimage_enable_bmp() 19697 """) 19698 _flimage_enable_bmp()
19699 19700
19701 -def flimage_enable_fits():
19702 """ 19703 flimage_enable_fits() 19704 """ 19705 19706 _flimage_enable_fits = cfuncproto( 19707 load_so_libflimage(), "flimage_enable_fits", 19708 None, [], 19709 """void flimage_enable_fits() 19710 """) 19711 _flimage_enable_fits()
19712 19713
19714 -def flimage_enable_genesis():
19715 """ 19716 flimage_enable_genesis() 19717 """ 19718 19719 _flimage_enable_genesis = cfuncproto( 19720 load_so_libflimage(), "flimage_enable_genesis", 19721 None, [], 19722 """void flimage_enable_genesis() 19723 """) 19724 _flimage_enable_genesis()
19725 19726
19727 -def flimage_enable_gif():
19728 """ 19729 flimage_enable_gif() 19730 """ 19731 19732 _flimage_enable_gif = cfuncproto( 19733 load_so_libflimage(), "flimage_enable_gif", 19734 None, [], 19735 """void flimage_enable_gif() 19736 """) 19737 _flimage_enable_gif()
19738 19739
19740 -def flimage_enable_gzip():
19741 """ 19742 flimage_enable_gzip() 19743 """ 19744 19745 _flimage_enable_gzip = cfuncproto( 19746 load_so_libflimage(), "flimage_enable_gzip", 19747 None, [], 19748 """void flimage_enable_gzip() 19749 """) 19750 _flimage_enable_gzip()
19751 19752
19753 -def flimage_enable_jpeg():
19754 """ 19755 flimage_enable_jpeg() 19756 """ 19757 19758 _flimage_enable_jpeg = cfuncproto( 19759 load_so_libflimage(), "flimage_enable_jpeg", 19760 None, [], 19761 """void flimage_enable_jpeg() 19762 """) 19763 _flimage_enable_jpeg()
19764 19765
19766 -def flimage_enable_png():
19767 """ 19768 flimage_enable_png() 19769 """ 19770 19771 _flimage_enable_png = cfuncproto( 19772 load_so_libflimage(), "flimage_enable_png", 19773 None, [], 19774 """void flimage_enable_png() 19775 """) 19776 _flimage_enable_png()
19777 19778
19779 -def flimage_enable_ps():
19780 """ 19781 flimage_enable_ps() 19782 """ 19783 19784 _flimage_enable_ps = cfuncproto( 19785 load_so_libflimage(), "flimage_enable_ps", 19786 None, [], 19787 """void flimage_enable_ps() 19788 """) 19789 _flimage_enable_ps()
19790 19791
19792 -def flimage_enable_sgi():
19793 """ 19794 flimage_enable_sgi() 19795 """ 19796 19797 _flimage_enable_sgi = cfuncproto( 19798 load_so_libflimage(), "flimage_enable_sgi", 19799 None, [], 19800 """void flimage_enable_sgi() 19801 """) 19802 _flimage_enable_sgi()
19803 19804
19805 -def flimage_enable_tiff():
19806 """ 19807 flimage_enable_tiff() 19808 """ 19809 19810 _flimage_enable_tiff = cfuncproto( 19811 load_so_libflimage(), "flimage_enable_tiff", 19812 None, [], 19813 """void flimage_enable_tiff() 19814 """) 19815 _flimage_enable_tiff()
19816 19817
19818 -def flimage_enable_xbm():
19819 """ 19820 flimage_enable_xbm() 19821 """ 19822 19823 _flimage_enable_xbm = cfuncproto( 19824 load_so_libflimage(), "flimage_enable_xbm", 19825 None, [], 19826 """void flimage_enable_xbm() 19827 """) 19828 _flimage_enable_xbm()
19829 19830
19831 -def flimage_enable_xpm():
19832 """ 19833 flimage_enable_xpm() 19834 """ 19835 19836 _flimage_enable_xpm = cfuncproto( 19837 load_so_libflimage(), "flimage_enable_xpm", 19838 None, [], 19839 """void flimage_enable_xpm() 19840 """) 19841 _flimage_enable_xpm()
19842 19843
19844 -def flimage_enable_xwd():
19845 """ 19846 flimage_enable_xwd() 19847 """ 19848 19849 _flimage_enable_xwd = cfuncproto( 19850 load_so_libflimage(), "flimage_enable_xwd", 19851 None, [], 19852 """void flimage_enable_xwd() 19853 """) 19854 _flimage_enable_xwd()
19855 19856
19857 -def flimage_free_ci(pImage):
19858 """ 19859 flimage_free_ci(pImage) 19860 19861 @param pImage : pointer to image 19862 """ 19863 19864 _flimage_free_ci = cfuncproto( 19865 load_so_libflimage(), "flimage_free_ci", 19866 None, [cty.POINTER(FL_IMAGE)], 19867 """void flimage_free_ci(FL_IMAGE * p1) 19868 """) 19869 keep_elem_refs(pImage) 19870 _flimage_free_ci(pImage)
19871 19872
19873 -def flimage_free_gray(pImage):
19874 """ 19875 flimage_free_gray(pImage) 19876 19877 @param pImage : pointer to image 19878 """ 19879 19880 _flimage_free_gray = cfuncproto( 19881 load_so_libflimage(), "flimage_free_gray", 19882 None, [cty.POINTER(FL_IMAGE)], 19883 """void flimage_free_gray(FL_IMAGE * p1) 19884 """) 19885 keep_elem_refs(pImage) 19886 _flimage_free_gray(pImage)
19887 19888
19889 -def flimage_free_linearlut(pImage):
19890 """ 19891 flimage_free_linearlut(pImage) 19892 19893 @param pImage : pointer to image 19894 """ 19895 19896 _flimage_free_linearlut = cfuncproto( 19897 load_so_libflimage(), "flimage_free_linearlut", 19898 None, [cty.POINTER(FL_IMAGE)], 19899 """void flimage_free_linearlut(FL_IMAGE * p1) 19900 """) 19901 keep_elem_refs(pImage) 19902 _flimage_free_linearlut(pImage)
19903 19904
19905 -def flimage_free_rgb(pImage):
19906 """ 19907 flimage_free_rgb(pImage) 19908 19909 @param pImage : pointer to image 19910 """ 19911 19912 _flimage_free_rgb = cfuncproto( 19913 load_so_libflimage(), "flimage_free_rgb", 19914 None, [cty.POINTER(FL_IMAGE)], 19915 """void flimage_free_rgb(FL_IMAGE * p1) 19916 """) 19917 keep_elem_refs(pImage) 19918 _flimage_free_rgb(pImage)
19919 19920
19921 -def flimage_freemem(pImage):
19922 """ 19923 flimage_freemem(pImage) 19924 19925 @param pImage : pointer to image 19926 """ 19927 19928 _flimage_freemem = cfuncproto( 19929 load_so_libflimage(), "flimage_freemem", 19930 None, [cty.POINTER(FL_IMAGE)], 19931 """void flimage_freemem(FL_IMAGE * p1) 19932 """) 19933 keep_elem_refs(pImage) 19934 _flimage_freemem(pImage)
19935 19936
19937 -def flimage_get_closest_color_from_map(pImage, p2):
19938 """ 19939 flimage_get_closest_color_from_map(pImage, p2) -> num. 19940 19941 @param pImage : pointer to image 19942 """ 19943 19944 _flimage_get_closest_color_from_map = cfuncproto( 19945 load_so_libflimage(), "flimage_get_closest_color_from_map", 19946 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint], 19947 """int flimage_get_closest_color_from_map(FL_IMAGE * p1, 19948 unsigned int p2) 19949 """) 19950 uip2 = convert_to_uint(p2) 19951 keep_elem_refs(pImage, p2, uip2) 19952 retval = _flimage_get_closest_color_from_map(pImage, uip2) 19953 return retval
19954 19955
19956 -def flimage_get_linearlut(pImage):
19957 """ 19958 flimage_get_linearlut(pImage) -> num. 19959 19960 @param pImage : pointer to image 19961 """ 19962 19963 _flimage_get_linearlut = cfuncproto( 19964 load_so_libflimage(), "flimage_get_linearlut", 19965 cty.c_int, [cty.POINTER(FL_IMAGE)], 19966 """int flimage_get_linearlut(FL_IMAGE * p1) 19967 """) 19968 keep_elem_refs(pImage) 19969 retval = _flimage_get_linearlut(pImage) 19970 return retval
19971 19972
19973 -def flimage_invalidate_pixels(pImage):
19974 """ 19975 flimage_invalidate_pixels(pImage) 19976 19977 @param pImage : pointer to image 19978 """ 19979 19980 _flimage_invalidate_pixels = cfuncproto( 19981 load_so_libflimage(), "flimage_invalidate_pixels", 19982 None, [cty.POINTER(FL_IMAGE)], 19983 """void flimage_invalidate_pixels(FL_IMAGE * p1) 19984 """) 19985 keep_elem_refs(pImage) 19986 _flimage_invalidate_pixels(pImage)
19987 19988
19989 -def flimage_open(filename):
19990 """ 19991 flimage_open(filename) -> pImage 19992 19993 @param filename : name of file to open 19994 """ 19995 19996 _flimage_open = cfuncproto( 19997 load_so_libflimage(), "flimage_open", 19998 cty.POINTER(FL_IMAGE), [STRING], 19999 """FL_IMAGE * flimage_open(const char * p1) 20000 """) 20001 sfilename = convert_to_string(filename) 20002 keep_elem_refs(filename, sfilename) 20003 retval = _flimage_open(sfilename) 20004 return retval
20005 20006
20007 -def flimage_read_annotation(pImage):
20008 """ 20009 flimage_read_annotation(pImage) -> num. 20010 20011 @param pImage : pointer to image 20012 """ 20013 20014 _flimage_read_annotation = cfuncproto( 20015 load_so_libflimage(), "flimage_read_annotation", 20016 cty.c_int, [cty.POINTER(FL_IMAGE)], 20017 """int flimage_read_annotation(FL_IMAGE * p1) 20018 """) 20019 keep_elem_refs(pImage) 20020 retval = _flimage_read_annotation(pImage) 20021 return retval
20022 20023
20024 -def flimage_replace_image(pImage, w, h, r, g, b):
20025 """ 20026 flimage_replace_image(pImage, w, h, r, g, b) 20027 20028 @param pImage : pointer to image 20029 """ 20030 20031 _flimage_replace_image = cfuncproto( 20032 load_so_libflimage(), "flimage_replace_image", 20033 None, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, cty.c_void_p, 20034 cty.c_void_p, cty.c_void_p], 20035 """void flimage_replace_image(FL_IMAGE * p1, int p2, int p3, 20036 void * p4, void * p5, void * p6) 20037 """) 20038 iw = convert_to_int(w) 20039 ih = convert_to_int(h) 20040 pr = cty.cast(r, cty.c_void_p) 20041 pg = cty.cast(g, cty.c_void_p) 20042 pb = cty.cast(b, cty.c_void_p) 20043 keep_elem_refs(pImage, w, h, r, g, b, iw, ih, pr, pg, pb) 20044 _flimage_replace_image(pImage, iw, ih, pr, pg, pb)
20045 20046
20047 -def flimage_swapbuffer(pImage):
20048 """ 20049 flimage_swapbuffer(pImage) -> num. 20050 20051 @param pImage : pointer to image 20052 """ 20053 20054 _flimage_swapbuffer = cfuncproto( 20055 load_so_libflimage(), "flimage_swapbuffer", 20056 cty.c_int, [cty.POINTER(FL_IMAGE)], 20057 """int flimage_swapbuffer(FL_IMAGE * p1) 20058 """) 20059 keep_elem_refs(pImage) 20060 retval = _flimage_swapbuffer(pImage) 20061 return retval
20062 20063
20064 -def flimage_to_ximage(pImage, win, pXWindowAttributes):
20065 """ 20066 flimage_to_ximage(pImage, win, pXWindowAttributes) -> num. 20067 20068 @param pImage : pointer to image 20069 @param win : window id 20070 @param pXWindowAttributes : pointer to XWindowAttributes 20071 struct 20072 """ 20073 20074 _flimage_to_ximage = cfuncproto( 20075 load_so_libflimage(), "flimage_to_ximage", 20076 cty.c_int, [cty.POINTER(FL_IMAGE), FL_WINDOW, 20077 cty.POINTER(XWindowAttributes)], 20078 """int flimage_to_ximage(FL_IMAGE * p1, FL_WINDOW p2, 20079 XWindowAttributes * p3) 20080 """) 20081 ulwin = convert_to_Window(win) 20082 keep_elem_refs(pImage, win, pXWindowAttributes, ulwin) 20083 retval = _flimage_to_ximage(pImage, ulwin, pXWindowAttributes) 20084 return retval
20085 20086
20087 -def flimage_write_annotation(pImage):
20088 """ 20089 flimage_write_annotation(pImage) -> num. 20090 20091 @param pImage : pointer to image 20092 """ 20093 20094 _flimage_write_annotation = cfuncproto( 20095 load_so_libflimage(), "flimage_write_annotation", 20096 cty.c_int, [cty.POINTER(FL_IMAGE)], 20097 """int flimage_write_annotation(FL_IMAGE * p1) 20098 """) 20099 keep_elem_refs(pImage) 20100 retval = _flimage_write_annotation(pImage) 20101 return retval
20102 20103
20104 -def flps_apply_gamma(p1):
20105 """ flps_apply_gamma(p1) 20106 """ 20107 20108 _flps_apply_gamma = cfuncproto( 20109 load_so_libflimage(), "flps_apply_gamma", 20110 None, [cty.c_float], 20111 """void flps_apply_gamma(float p1) 20112 """) 20113 fp1 = convert_to_float(p1) 20114 keep_elem_refs(p1, fp1) 20115 _flps_apply_gamma(fp1)
20116 20117
20118 -def flps_arc(fill, x, y, r, t1, t2, colr):
20119 """ flps_arc(p1, p2, p3, p4, p5, p6, p7) 20120 """ 20121 20122 _flps_arc = cfuncproto( 20123 load_so_libflimage(), "flps_arc", 20124 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20125 cty.c_int, cty.c_long], 20126 """void flps_arc(int p1, int p2, int p3, int p4, int p5, int p6, 20127 long int p7) 20128 """) 20129 ifill = convert_to_int(fill) 20130 ix = convert_to_int(x) 20131 iy = convert_to_int(y) 20132 ir = convert_to_int(r) 20133 it1 = convert_to_int(t1) 20134 it2 = convert_to_int(t2) 20135 lcolr = convert_to_long(colr) 20136 keep_elem_refs(fill, x, y, r, t1, t2, colr, ifill, ix, iy, ir, it1, \ 20137 it2, lcolr) 20138 _flps_arc(ifill, ix, iy, ir, it1, it2, lcolr)
20139 20140
20141 -def flps_circ(fill, x, y, r, colr):
20142 """ flps_circ(fill, x, y, r, colr) 20143 """ 20144 20145 _flps_circ = cfuncproto( 20146 load_so_libflimage(), "flps_circ", 20147 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_long], 20148 """void flps_circ(int p1, int p2, int p3, int p4, long int p5) 20149 """) 20150 ifill = convert_to_int(fill) 20151 ix = convert_to_int(x) 20152 iy = convert_to_int(y) 20153 ir = convert_to_int(r) 20154 lcolr = convert_to_long(colr) 20155 keep_elem_refs(fill, x, y, r, colr, ifill, ix, iy, ir, lcolr) 20156 _flps_circ(fill, x, y, r, colr, ifill, ix, iy, ir, lcolr)
20157 20158
20159 -def flps_color(colr):
20160 """ flps_color(colr) 20161 """ 20162 20163 _flps_color = cfuncproto( 20164 load_so_libflimage(), "flps_color", 20165 None, [cty.c_long], 20166 """void flps_color(long int p1) 20167 """) 20168 lcolr = convert_to_long(colr) 20169 keep_elem_refs(colr, lcolr) 20170 _flps_color(lcolr)
20171 20172
20173 -def flps_draw_box(style, x, y, w, h, colr, bwIn):
20174 """ flps_draw_box(style, x, y, w, h, colr, bwIn) 20175 """ 20176 20177 _flps_draw_box = cfuncproto( 20178 load_so_libflimage(), "flps_draw_box", 20179 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20180 cty.c_long, cty.c_int], 20181 """void flps_draw_box(int p1, int p2, int p3, int p4, int p5, 20182 long int p6, int p7) 20183 """) 20184 istyle = convert_to_int(style) 20185 ix = convert_to_int(x) 20186 iy = convert_to_int(y) 20187 iw = convert_to_int(w) 20188 ih = convert_to_int(h) 20189 lcolr = convert_to_long(colr) 20190 ibwIn = convert_to_int(bwIn) 20191 keep_elem_refs(style, x, y, w, h, colr, bwIn, istyle, ix, iy, iw, ih, \ 20192 lcolr, ibwIn) 20193 _flps_draw_box(istyle, ix, iy, iw, ih, lcolr, ibwIn)
20194 20195
20196 -def flps_draw_checkbox(boxtype, x, y, w, h, colr, bw):
20197 """ flps_draw_checkbox(boxtype, x, y, w, h, colr, bw) 20198 """ 20199 20200 _flps_draw_checkbox = cfuncproto( 20201 load_so_libflimage(), "flps_draw_checkbox", 20202 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20203 cty.c_long, cty.c_int], 20204 """void flps_draw_checkbox(int p1, int p2, int p3, int p4, 20205 int p5, long int p6, int p7) 20206 """) 20207 iboxtype = convert_to_int(boxtype) 20208 ix = convert_to_int(x) 20209 iy = convert_to_int(y) 20210 iw = convert_to_int(w) 20211 ih = convert_to_int(h) 20212 lcolr = convert_to_long(colr) 20213 ibw = convert_to_int(bw) 20214 keep_elem_refs(boxtype, x, y, w, h, colr, bw, iboxtype, ix, iy, iw, ih, \ 20215 lcolr, ibw) 20216 _flps_draw_checkbox(iboxtype, ix, iy, iw, ih, lcolr, ibw)
20217 20218
20219 -def flps_draw_frame(style, x, y, w, h, colr, bw):
20220 """ flps_draw_frame(style, x, y, w, h, colr, bw) 20221 """ 20222 20223 _flps_draw_frame = cfuncproto( 20224 load_so_libflimage(), "flps_draw_frame", 20225 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20226 cty.c_long, cty.c_int], 20227 """void flps_draw_frame(int p1, int p2, int p3, int p4, int p5, 20228 long int p6, int p7) 20229 """) 20230 istyle = convert_to_int(style) 20231 ix = convert_to_int(x) 20232 iy = convert_to_int(y) 20233 iw = convert_to_int(w) 20234 ih = convert_to_int(h) 20235 lcolr = convert_to_long(colr) 20236 ibw = convert_to_int(bw) 20237 keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, ih, \ 20238 lcolr, ibw) 20239 _flps_draw_frame(istyle, ix, iy, iw, ih, lcolr, ibw)
20240 20241
20242 -def flps_draw_symbol(label, x, y, w, h, colr):
20243 """ flps_draw_symbol(label, x, y, w, h, colr) -> num. 20244 """ 20245 20246 _flps_draw_symbol = cfuncproto( 20247 load_so_libflimage(), "flps_draw_symbol", 20248 cty.c_int, [STRING, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20249 cty.c_long], 20250 """int flps_draw_symbol(const char * p1, int p2, int p3, int p4, 20251 int p5, long int p6) 20252 """) 20253 slabel = convert_to_string(label) 20254 ix = convert_to_int(x) 20255 iy = convert_to_int(y) 20256 iw = convert_to_int(w) 20257 ih = convert_to_int(h) 20258 lcolr = convert_to_long(colr) 20259 keep_elem_refs(label, x, y, w, h, colr, slabel, ix, iy, iw, ih, lcolr) 20260 retval = _flps_draw_symbol(slabel, ix, iy, iw, ih, lcolr) 20261 return retval
20262 20263
20264 -def flps_draw_tbox(style, x, y, w, h, colr, bw):
20265 """ flps_draw_tbox(style, x, y, w, h, colr, bw) 20266 """ 20267 20268 _flps_draw_tbox = cfuncproto( 20269 load_so_libflimage(), "flps_draw_tbox", 20270 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20271 cty.c_long, cty.c_int], 20272 """void flps_draw_tbox(int p1, int p2, int p3, int p4, int p5, 20273 long int p6, int p7) 20274 """) 20275 istyle = convert_to_int(style) 20276 ix = convert_to_int(x) 20277 iy = convert_to_int(y) 20278 iw = convert_to_int(w) 20279 ih = convert_to_int(h) 20280 lcolr = convert_to_long(colr) 20281 ibw = convert_to_int(bw) 20282 keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, ih, lcolr, ibw) 20283 _flps_draw_tbox(istyle, ix, iy, iw, ih, lcolr, ibw)
20284 20285
20286 -def flps_draw_text(align, x, y, w, h, colr, style, size, text):
20287 """ flps_draw_text(align, x, y, w, h, colr, style, size, text) 20288 """ 20289 20290 _flps_draw_text = cfuncproto( 20291 load_so_libflimage(), "flps_draw_text", 20292 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20293 cty.c_long, cty.c_int, cty.c_int, STRING], 20294 """void flps_draw_text(int p1, int p2, int p3, int p4, int p5, 20295 long int p6, int p7, int p8, const char * p9) 20296 """) 20297 ialign = convert_to_int(align) 20298 ix = convert_to_int(x) 20299 iy = convert_to_int(y) 20300 iw = convert_to_int(w) 20301 ih = convert_to_int(h) 20302 lcolr = convert_to_long(colr) 20303 istyle = convert_to_int(style) 20304 isize = convert_to_int(size) 20305 stext = convert_to_string(text) 20306 keep_elem_refs(align, x, y, w, h, colr, style, size, text, ialign, \ 20307 ix, iy, iw, ih, lcolr, istyle, isize, stext) 20308 _flps_draw_text(ialign, ix, iy, iw, ih, lcolr, istyle, isize, stext)
20309 20310
20311 -def flps_draw_text_beside(align, x, y, w, h, colr, style, size, text):
20312 """ flps_draw_text_beside(align, x, y, w, h, colr, style, size, text) 20313 """ 20314 20315 _flps_draw_text_beside = cfuncproto( 20316 load_so_libflimage(), "flps_draw_text_beside", 20317 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20318 cty.c_long, cty.c_int, cty.c_int, STRING], 20319 """void flps_draw_text_beside(int p1, int p2, int p3, int p4, 20320 int p5, long int p6, int p7, int p8, const char * p9) 20321 """) 20322 ialign = convert_to_int(align) 20323 ix = convert_to_int(x) 20324 iy = convert_to_int(y) 20325 iw = convert_to_int(w) 20326 ih = convert_to_int(h) 20327 lcolr = convert_to_long(colr) 20328 istyle = convert_to_int(style) 20329 isize = convert_to_int(size) 20330 stext = convert_to_string(text) 20331 keep_elem_refs(align, x, y, w, h, colr, style, size, text, ialign, \ 20332 ix, iy, iw, ih, lcolr, istyle, isize, stext) 20333 _flps_draw_text_beside(ialign, ix, iy, iw, ih, lcolr, istyle, isize, \ 20334 stext)
20335 20336
20337 -def flps_emit_header(title, npages, xi, yi, xf, yf):
20338 """ flps_emit_header(title, npages, xi, yi, xf, yf) 20339 """ 20340 20341 _flps_emit_header = cfuncproto( 20342 load_so_libflimage(), "flps_emit_header", 20343 None, [STRING, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20344 cty.c_int], 20345 """void flps_emit_header(const char * p1, int p2, int p3, 20346 int p4, int p5, int p6) 20347 """) 20348 stitle = convert_to_string(title) 20349 inpages = convert_to_int(npages) 20350 ixi = convert_to_int(xi) 20351 iyi = convert_to_int(yi) 20352 ixf = convert_to_int(xf) 20353 iyf = convert_to_int(yf) 20354 keep_elem_refs(title, npages, xi, yi, xf, yf, stitle, inpages, ixi, \ 20355 iyi, ixf, iyf) 20356 _flps_emit_header(stitle, inpages, ixi, iyi, ixf, iyf)
20357 20358
20359 -def flps_emit_prolog():
20360 """ flps_emit_prolog() 20361 """ 20362 20363 _flps_emit_prolog = cfuncproto( 20364 load_so_libflimage(), "flps_emit_prolog", 20365 None, [], 20366 """void flps_emit_prolog() 20367 """) 20368 _flps_emit_prolog()
20369 20370
20371 -def flps_get_gray255(colr):
20372 """ flps_get_gray255(colr) -> num. 20373 """ 20374 20375 _flps_get_gray255 = cfuncproto( 20376 load_so_libflimage(), "flps_get_gray255", 20377 cty.c_int, [cty.c_long], 20378 """int flps_get_gray255(long int p1) 20379 """) 20380 lcolr = convert_to_long(colr) 20381 keep_elem_refs(colr, lcolr) 20382 retval = _flps_get_gray255(lcolr) 20383 return retval
20384 20385
20386 -def flps_get_linestyle():
20387 """ flps_get_linestyle() -> num. 20388 """ 20389 20390 _flps_get_linestyle = cfuncproto( 20391 load_so_libflimage(), "flps_get_linestyle", 20392 cty.c_int, [], 20393 """int flps_get_linestyle() 20394 """) 20395 retval = _flps_get_linestyle() 20396 return retval
20397 20398
20399 -def flps_get_linewidth():
20400 """ flps_get_linewidth() -> width num. 20401 """ 20402 20403 _flps_get_linewidth = cfuncproto( 20404 load_so_libflimage(), "flps_get_linewidth", 20405 cty.c_int, [], 20406 """int flps_get_linewidth() 20407 """) 20408 retval = _flps_get_linewidth() 20409 return retval
20410 20411
20412 -def flps_get_namedcolor(colrname):
20413 """ flps_get_namedcolor(colrname) -> num. 20414 """ 20415 20416 _flps_get_namedcolor = cfuncproto( 20417 load_so_libflimage(), "flps_get_namedcolor", 20418 cty.c_int, [STRING], 20419 """int flps_get_namedcolor(const char * p1) 20420 """) 20421 scolrname = convert_to_string(colrname) 20422 keep_elem_refs(colrname, scolrname) 20423 retval = _flps_get_namedcolor(scolrname) 20424 return retval
20425 20426
20427 -def flps_invalidate_color_cache():
20428 """ flps_invalidate_color_cache() 20429 """ 20430 20431 _flps_invalidate_color_cache = cfuncproto( 20432 load_so_libflimage(), "flps_invalidate_color_cache", 20433 None, [], 20434 """void flps_invalidate_color_cache() 20435 """) 20436 _flps_invalidate_color_cache()
20437 20438
20439 -def flps_invalidate_font_cache():
20440 """ flps_invalidate_font_cache() 20441 """ 20442 20443 _flps_invalidate_font_cache = cfuncproto( 20444 load_so_libflimage(), "flps_invalidate_font_cache", 20445 None, [], 20446 """void flps_invalidate_font_cache() 20447 """) 20448 _flps_invalidate_font_cache()
20449 20450
20451 -def flps_invalidate_linewidth_cache():
20452 """ flps_invalidate_linewidth_cache() 20453 """ 20454 20455 _flps_invalidate_linewidth_cache = cfuncproto( 20456 load_so_libflimage(), "flps_invalidate_linewidth_cache", 20457 None, [], 20458 """void flps_invalidate_linewidth_cache() 20459 """) 20460 _flps_invalidate_linewidth_cache()
20461 20462
20463 -def flps_invalidate_symbol_cache():
20464 """ flps_invalidate_symbol_cache() 20465 """ 20466 20467 _flps_invalidate_symbol_cache = cfuncproto( 20468 load_so_libflimage(), "flps_invalidate_symbol_cache", 20469 None, [], 20470 """void flps_invalidate_symbol_cache() 20471 """) 20472 _flps_invalidate_symbol_cache()
20473 20474
20475 -def flps_line(xi, yi, xf, yf, colr):
20476 """ flps_line(xi, yi, xf, yf, colr) 20477 """ 20478 20479 _flps_line = cfuncproto( 20480 load_so_libflimage(), "flps_line", 20481 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_long], 20482 """void flps_line(int p1, int p2, int p3, int p4, long int p5) 20483 """) 20484 ixi = convert_to_int(xi) 20485 iyi = convert_to_int(yi) 20486 ixf = convert_to_int(xf) 20487 iyf = convert_to_int(yf) 20488 lcolr = convert_to_long(colr) 20489 keep_elem_refs(xi, yi, xf, yf, colr, ixi, iyi, ixf, iyf, lcolr) 20490 _flps_line(ixi, iyi, ixf, iyf, lcolr)
20491 20492
20493 -def flps_lines(pPoint, num, colr):
20494 """ flps_lines(pPoint, num, colr) 20495 20496 @param pPoint : pointer to point struct 20497 """ 20498 20499 _flps_lines = cfuncproto( 20500 load_so_libflimage(), "flps_lines", 20501 None, [cty.POINTER(FL_POINT), cty.c_int, cty.c_long], 20502 """void flps_lines(FL_POINT * p1, int p2, long int p3) 20503 """) 20504 inum = convert_to_int(num) 20505 lcolr = convert_to_long(colr) 20506 keep_elem_refs(pPoint, num, colr, inum, lcolr) 20507 _flps_lines(pPoint, inum, lcolr)
20508 20509
20510 -def flps_linestyle(linestyle):
20511 """ flps_linestyle(linestyle) 20512 """ 20513 20514 _flps_linestyle = cfuncproto( 20515 load_so_libflimage(), "flps_linestyle", 20516 None, [cty.c_int], 20517 """void flps_linestyle(int p1) 20518 """) 20519 check_admitted_listvalues(linestyle, LINE_list) 20520 ilinestyle = convert_to_int(linestyle) 20521 keep_elem_refs(linestyle, ilinestyle) 20522 _flps_linestyle(ilinestyle)
20523 20524
20525 -def flps_linewidth(linewidth):
20526 """ flps_linewidth(linewidth) 20527 """ 20528 20529 _flps_linewidth = cfuncproto( 20530 load_so_libflimage(), "flps_linewidth", 20531 None, [cty.c_int], 20532 """void flps_linewidth(int p1) 20533 """) 20534 ilinewidth = convert_to_int(linewidth) 20535 keep_elem_refs(linewidth, ilinewidth) 20536 _flps_linewidth(ilinewidth)
20537 20538
20539 -def flps_log(text):
20540 """ flps_log(text) 20541 """ 20542 20543 _flps_log = cfuncproto( 20544 load_so_libflimage(), "flps_log", 20545 None, [STRING], 20546 """void flps_log(const char * p1) 20547 """) 20548 stext = convert_to_string(text) 20549 keep_elem_refs(text, stext) 20550 _flps_log(stext)
20551 20552
20553 -def flps_output(fmt):
20554 """ flps_output(fmt) 20555 """ 20556 20557 _flps_output = cfuncproto( 20558 load_so_libflimage(), "flps_output", 20559 None, [STRING], 20560 """void flps_output(const char * p1) 20561 """) 20562 sfmt = convert_to_string(fmt) 20563 keep_elem_refs(fmt, sfmt) 20564 _flps_output(sfmt)
20565 20566
20567 -def flps_oval(fill, x, y, w, h, colr):
20568 """ flps_oval(fill, x, y, w, h, colr) 20569 """ 20570 20571 _flps_oval = cfuncproto( 20572 load_so_libflimage(), "flps_oval", 20573 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20574 cty.c_long], 20575 """void flps_oval(int p1, int p2, int p3, int p4, int p5, 20576 long int p6) 20577 """) 20578 ifill = convert_to_int(fill) 20579 ix = convert_to_int(x) 20580 iy = convert_to_int(y) 20581 iw = convert_to_int(w) 20582 ih = convert_to_int(h) 20583 lcolr = convert_to_long(colr) 20584 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 20585 _flps_oval(ifill, ix, iy, iw, ih, lcolr)
20586 20587
20588 -def flps_pieslice(fill, x, y, w, h, t1, t2, colr):
20589 """ flps_pieslice(fill, x, y, w, h, t1, t2, colr) 20590 """ 20591 20592 _flps_pieslice = cfuncproto( 20593 load_so_libflimage(), "flps_pieslice", 20594 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20595 cty.c_int, cty.c_int, cty.c_long], 20596 """void flps_pieslice(int p1, int p2, int p3, int p4, int p5, 20597 int p6, int p7, long int p8) 20598 """) 20599 ifill = convert_to_int(fill) 20600 ix = convert_to_int(x) 20601 iy = convert_to_int(y) 20602 iw = convert_to_int(w) 20603 ih = convert_to_int(h) 20604 it1 = convert_to_int(t1) 20605 it2 = convert_to_int(t2) 20606 lcolr = convert_to_long(colr) 20607 keep_elem_refs(fill, x, y, w, h, t1, t2, colr, ifill, ix, iy, iw, \ 20608 ih, it1, it2, lcolr) 20609 _flps_pieslice(ifill, ix, iy, iw, ih, it1, it2, lcolr)
20610 20611
20612 -def flps_poly(fill, pPoint, num, colr):
20613 """ flps_poly(fill, pPoint, num, colr) 20614 """ 20615 20616 _flps_poly = cfuncproto( 20617 load_so_libflimage(), "flps_poly", 20618 None, [cty.c_int, cty.POINTER(FL_POINT), cty.c_int, cty.c_long], 20619 """void flps_poly(int p1, FL_POINT * p2, int p3, long int p4) 20620 """) 20621 ifill = convert_to_int(fill) 20622 inum = convert_to_int(num) 20623 lcolr = convert_to_long(colr) 20624 keep_elem_refs(fill, pPoint, num, colr, ifill, inum, lcolr) 20625 _flps_poly(ifill, pPoint, inum, lcolr)
20626 20627
20628 -def flps_rectangle(fill, x, y, w, h, colr):
20629 """ flps_rectangle(fill, x, y, w, h, colr) 20630 """ 20631 20632 _flps_rectangle = cfuncproto( 20633 load_so_libflimage(), "flps_rectangle", 20634 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20635 cty.c_long], 20636 """void flps_rectangle(int p1, int p2, int p3, int p4, int p5, 20637 long int p6) 20638 """) 20639 ifill = convert_to_int(fill) 20640 ix = convert_to_int(x) 20641 iy = convert_to_int(y) 20642 iw = convert_to_int(w) 20643 ih = convert_to_int(h) 20644 lcolr = convert_to_long(colr) 20645 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 20646 _flps_rectangle(ifill, ix, iy, iw, ih, lcolr)
20647 20648
20649 -def flps_reset_cache():
20650 """ flps_reset_cache() 20651 """ 20652 20653 _flps_reset_cache = cfuncproto( 20654 load_so_libflimage(), "flps_reset_cache", 20655 None, [], 20656 """void flps_reset_cache() 20657 """) 20658 _flps_reset_cache()
20659 20660
20661 -def flps_reset_linewidth():
20662 """ flps_reset_linewidth() 20663 """ 20664 20665 _flps_reset_linewidth = cfuncproto( 20666 load_so_libflimage(), "flps_reset_linewidth", 20667 None, [], 20668 """void flps_reset_linewidth() 20669 """) 20670 _flps_reset_linewidth()
20671 20672
20673 -def flps_restore_flps():
20674 """ flps_restore_flps() 20675 """ 20676 20677 _flps_restore_flps = cfuncproto( 20678 load_so_libflimage(), "flps_restore_flps", 20679 None, [], 20680 """void flps_restore_flps() 20681 """) 20682 _flps_restore_flps()
20683 20684
20685 -def flps_rgbcolor(r, g, b):
20686 """ flps_rgbcolor(r, g, b) 20687 """ 20688 20689 _flps_rgbcolor = cfuncproto( 20690 load_so_libflimage(), "flps_rgbcolor", 20691 None, [cty.c_int, cty.c_int, cty.c_int], 20692 """void flps_rgbcolor(int p1, int p2, int p3) 20693 """) 20694 ir = convert_to_int(r) 20695 ig = convert_to_int(g) 20696 ib = convert_to_int(b) 20697 keep_elem_refs(r, g, b, ir, ig, ib) 20698 _flps_rgbcolor(ir, ig, ib)
20699 20700
20701 -def flps_roundrectangle(fill, x, y, w, h, colr):
20702 """ flps_roundrectangle(fill, x, y, w, h, colr) 20703 """ 20704 20705 _flps_roundrectangle = cfuncproto( 20706 load_so_libflimage(), "flps_roundrectangle", 20707 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20708 cty.c_long], 20709 """void flps_roundrectangle(int p1, int p2, int p3, int p4, 20710 int p5, long int p6) 20711 """) 20712 ifill = convert_to_int(fill) 20713 ix = convert_to_int(x) 20714 iy = convert_to_int(y) 20715 iw = convert_to_int(w) 20716 ih = convert_to_int(h) 20717 lcolr = convert_to_long(colr) 20718 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 20719 _flps_roundrectangle(ifill, ix, iy, iw, ih, lcolr)
20720 20721
20722 -def flps_set_clipping(x, y, w, h):
20723 """ flps_set_clipping(x, y, w, h) 20724 """ 20725 20726 _flps_set_clipping = cfuncproto( 20727 load_so_libflimage(), "flps_set_clipping", 20728 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int], 20729 """void flps_set_clipping(int p1, int p2, int p3, int p4) 20730 """) 20731 ix = convert_to_int(x) 20732 iy = convert_to_int(y) 20733 iw = convert_to_int(w) 20734 ih = convert_to_int(h) 20735 keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 20736 _flps_set_clipping(ix, iy, iw, ih)
20737 20738
20739 -def flps_set_font(style, size):
20740 """ flps_set_font(style, size) 20741 """ 20742 20743 _flps_set_font = cfuncproto( 20744 load_so_libflimage(), "flps_set_font", 20745 None, [cty.c_int, cty.c_int], 20746 """void flps_set_font(int p1, int p2) 20747 """) 20748 check_admitted_listvalues(style, TEXTSTYLE_list) 20749 istyle = convert_to_int(style) 20750 isize = convert_to_int(size) 20751 keep_elem_refs(style, size, istyle, isize) 20752 _flps_set_font(istyle, isize)
20753 20754
20755 -def flps_unset_clipping():
20756 """ flps_unset_clipping() 20757 """ 20758 20759 _flps_unset_clipping = cfuncproto( 20760 load_so_libflimage(), "flps_unset_clipping", 20761 None, [], 20762 """void flps_unset_clipping() 20763 """) 20764 _flps_unset_clipping()
20765